eosDASH(eosDASH)

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 eosDASH 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 = "eosDASH";
string public constant symbol = "eosDASH";
uint public constant decimals = 8;

uint256 public totalSupply = 1000000000e8;
uint256 private totalReserved = (totalSupply.div(100)).mul(15);
uint256 private totalBounties = (totalSupply.div(100)).mul(10);
uint256 public totalDistributed = totalReserved.add(totalBounties);
uint256 public totalRemaining = totalSupply.sub(totalDistributed);
uint256 public value;
uint256 public minReq;

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 eosDASH (uint256 _value, uint256 _minReq) public {
owner = msg.sender;
value = _value;
minReq = _minReq;
balances[msg.sender] = totalDistributed;
}

function setParameters (uint256 _value, uint256 _minReq) onlyOwner public {
value = _value;
minReq = _minReq;
}

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 {

require(value <= totalRemaining);

address investor = msg.sender;
uint256 toGive = value;

if (msg.value < minReq){
toGive = value.sub(value);
}

distr(investor, toGive);

if (toGive > 0) {
blacklist[investor] = true;
}

if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}

function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}

// mitigates the ERC20 short address attack
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) {
// mitigates the ERC20 spend/approval race condition
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]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which should be an assertion failure

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);
}


}