SimpleToken

CrowdSale.sol

pragma solidity ^0.4.18;



import "zeppelin-solidity/contracts/token/StandardToken.sol";
import "./SimpleToken.sol";
import "./WhiteListable.sol";
import "zeppelin-solidity/contracts/lifecycle/Pausable.sol";



contract CrowdSale is Pausable, WhiteListable {

  using SafeMath for uint256;

  uint256 constant public DECIMALS = 18;
  uint256 constant public RESERVED_TOKENS_FOUNDERS = 23e6 * (10 ** DECIMALS);
  uint256 constant public RESERVED_TOKENS_OPERATIONAL_EXPENSES = 2e6 * (10 ** DECIMALS);
  uint256 constant public HARDCAP_TOKENS_PRE_ICO = 5e6 * (10 ** DECIMALS);  //5e27
  uint256 constant public HARDCAP_TOKENS_ICO = 70e6 * (10 ** DECIMALS); //1e8 * (10 ** DECIMALS)

  uint256 public minCap; //in tokens

  uint256 public startPreICO;
  uint256 public endPreICO;
  uint256 public startICO;
  uint256 public endICO;

  uint256 public PreICORate;  // 1 Ether = 100 SimpleToken
  uint256 public ICORate;
  uint256 public TokenSoldPreICO; //Token
  uint256 public TokenSoldICO; //Token

  uint256 public weiRaisedPreICO; //Ether
  uint256 public weiRaisedICO; //Ether

  /* uint256 public bonusPeriod1 = 20;
  uint256 public bonusPeriod2 = 10;  */

  uint256 public period1 = 24 * 60 * 60; // = 1518776400; *set bonus dates here
  uint256 public period2 = 7 * 24 * 60 * 60; // = 1518777000; *set bonus dates here

  address[] private investorsPreICO;
  address private withdrawWallet;
  /* address[] private investorsICO; */

  uint256 public tokensRemindingICO = HARDCAP_TOKENS_PRE_ICO.add(HARDCAP_TOKENS_ICO);

  SimpleToken public token = SimpleToken(this);

  function CrowdSale(uint256 _startPreICO,
                     uint256 _endPreICO,
                     uint256 _startICO,
                     uint256 _endICO,
                     uint256 _PreICORate,
                     uint256 _ICORate,
                     uint256 _minCap,
                     address _founders,
                     address _operational,
                     address _withdrawWallet
                     ) WhiteListable() public {
    require(_founders != address(0x0) && _operational != address(0x0) && _withdrawWallet != address(0x0));
    require(_endPreICO > _startPreICO && _startICO > now);
    require(_endICO > _startICO && _startICO > now && _startICO > _endPreICO);
    require(_PreICORate > 0 && _ICORate > 0);

    startPreICO = _startPreICO;
    endPreICO = _endPreICO;
    startICO = _startICO;
    endICO = _endICO;
    PreICORate = _PreICORate;
    ICORate = _ICORate;
    minCap = _minCap;
    withdrawWallet = _withdrawWallet;

    token.transferFromICO(_founders, RESERVED_TOKENS_FOUNDERS);
    token.transferFromICO(_operational, RESERVED_TOKENS_OPERATIONAL_EXPENSES);
    token.transferOwnership(msg.sender);
  }

    modifier whenICOSaleHasEnded() {
      require(now > _endICO);
      _;
    }

    modifier whenPreICOSaleHasEnded() {
      require(now > _endPreICO);
      _;
    }

    function isPreICO() public constant returns(bool) {
      return now >= _startPreICO && now <= _endPreICO;
    }

    function isICO() public constant returns(bool) {
      return now >= _startICO && now <= _endICO;
    }

    function minCapReached() public constant returns(bool) {
      return TokenSoldPreICO >= minCap;
    }

    function SetWithdrawWallet(address _withdrawWallet) onlyOwner public {
      require(_withdrawWallet != address(0x0));
      withdrawWallet = _withdrawWallet;
    }

    /* uint256 _startICO,
    uint256 _endICO,
    uint256 _PreICORate,
    uint256 _ICORate, */

    function () public payable {
      if(isPreICO()) {
        saleTokensPreICO();
      } else if (isICO()) {
        saleTokenICO();
      } else {
        revert();
      }
    }

    function getBonusByTime() private returns(uint256) {
      if(now >= startPreICO && now <= startPreICO.add(period1)) {
        return 20;
      }
      if(now >= startPreICO && now <= startPreICO.add(period2)) {
        return 10;
      }
      return 0;
    }

    function getBonusByAmount(uint256 _amount) private returns(uint256) {
      if(_amount >= 10 * (1 * Ether)) {   //10e18
        return _amount.mul(PreICORate).mul(110).div(100);
      }
      if(_amount >= 5 * (1 * Ether)) {   //5e18
        return _amount.mul(PreICORate).mul(105).div(100);
      }
      return _amount.mul(PreICORate);
    }

    function saleTokenPreICO() public payable whenNotPause whenWhiteListed {
      require(isPreICO());
      require(msg.value > 0);
      uint256 weiAmount = msg.value;
      weiRaisedPreICO = weiRaisedPreICO.add(weiAmount);
      addInvestmentPreICO(msg.sender, weiAmount);
      uint256 tokenAmountByTime = weiAmount.mul(PreICORate).mul(100 + getBonusByTime()).div(100);
      uint256 tokenAmountByAmount = getBonusByAmount(weiAmount);
      uint256 tokenAmount = tokenAmountByTime.add(tokenAmountByAmount);
      token.transferFromICO(msg.sender, tokenAmount);
      TokenSoldPreICO = TokenSoldPreICO.add(tokenAmount);
      tokensRemindingICO = tokensRemindingICO.sub(tokenAmount);
    }

    function saleTokenICO() public payable whenNotPause whenWhiteListed {
      require(isICO());
      require(msg.value > 0);
      uint256 weiAmount = msg.value;
      weiRaisedICO = weiRaisedICO.add(weiAmount);
      /* addInvestmentICO(msg.sender, weiAmount); */
      uint256 tokenAmount = weiAmount.mul(ICORate);
      token.transferFromICO(msg.sender, tokenAmount);
      TokenSoldICO = TokenSoldICO.add(tokenAmount);
      tokensRemindingICO = tokensRemindingICO.sub(tokenAmount);
      withdrawWallet.transfer(weiAmount); //transfer money imideatelly
    }

    function addInvestmentPreICO(address _from, uint256 _value) internal {
      if(investorsPreICO[_from] == 0){
        investorsPreICO.push(_from);
      }
      investorsPreICO[_from] = investorsPreICO[_from].add(_value);
    }

    function burnUnsoldTokens() whenICOSaleHasEnded onlyOwner public {
      token.burnFromICO();
      tokensRemindingICO = 0;
    }

    function withdrawPreICO() onlyOwner whenPreICOSaleHasEnded external {
      require(minCapReached());
      withdrawalPreICO.transfer(weiRaisedPreICO);
    }

    function refund() whenPreICOSaleHasEnded external {
      require(minCapReached() == false);
      require(investorsPreICO[msg.sender] > 0);
      uint256 weiAmount = investorsPreICO[msg.sender];
      uint256 tokenAmount = weiAmount.mul(PreICORate);
      investorsPreICO[msg.sender] = investorsPreICO[msg.sender].sub(weiAmount);
      token.burnFrom(msg.sender, tokenAmount);
      msg.sender.transfer(weiAmount);
    }
    //referal bonuses (123123123) 2% 3%
    function manualTransferToken(address _to, uint256 _amount) onlyOwner external {
      require(_to != address(0x0));
      token.transferFromICO(_to, _amount);
      tokensRemindingICO = tokensRemindingICO.sub(_amount);
    }


}


//whitelist

//bonuses by time

//bonuses by amount
















//

SimpleToken.sol

pragma solidity ^0.4.18;



import "zeppelin-solidity/contracts/token/BurnableToken.sol";
import "zeppelin-solidity/contracts/lifecycle/Pausable.sol";



contract SimpleToken is BurnableToken, Pausable {

  using SafeMath for uint256;

  string public constant name = "SimpleToken";
  string public constant symbol = "ST";
  uint256 public constant decimals = 18;
  address private addressICO;
  uint256 public constant INITIAL_TOTAL_SUPPLY = 100e6 * (10 ** DECIMALS);

  modifier onlyICO() {
    require(msg.sender == addressICO);
    _;
  }

  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 SimpleToken(address _addressICO) public {
    require (_addressICO != address(0x0));
    addressICO = _addressICO;
    totalSupple = totalSupply.add(INITIAL_TOTAL_SUPPLY);
    balances[_addressICO] = balances[_addressICO].add(INITIAL_TOTAL_SUPPLY);
    Transfer(address(0x0), _addressICO, INITIAL_TOTAL_SUPPLY);
    pause();
  }

  function transferFromICO(address addressSale, uint256 amount) public onlyICO {
    super.transfer(addressICO, addressSale, amount);
  }
}

WhiteList.sol

pragma solidity ^0.4.18;



import "zeppelin-solidity/contracts/ownership/Ownable.sol";



contract WhiteList is Ownable {

  using SafeMath for uint256;

  mapping(address => bool) whiteList;
  uint256 public whiteListLength = 0;

  function addWallet(address _wallet) onlyOwner public {
    require(_wallet != address(0x0));
    require(!isWhiteListed(_wallet));

    whiteList[_wallet] = true;
    whiteListLength++;
  }

  function deleteWallet(address _wallet) onlyOwner public {
    require(_wallet != address(0x0));
    require(isWhiteListed(_wallet));

    whiteList[_wallet] = false;
    whiteListLength--;
  }

  function isWhiteListed(address _wallet) public returns(bool) {
    return whiteList[_wallet];
  }
}















//

WhiteListable.sol

pragma solidity ^0.4.18;



import "./WhiteList.sol";



contract WhiteListable {
    WhiteList public whiteList;

    modifier whenWhiteListed(address _wallet) {
        require(whiteList.isWhiteListed(_wallet));
        _;
    }

    function WhiteListable() public {
        whiteList = new WhiteList();
    }
}