Contract Overview
Balance: 0 Ether
Ether Value: $0
Transactions: 375 txns
Token Tracker: dHealth (dHt)
Misc:
Address Watch: Add To Watch List
Contract Creator: 0x4c5c80a84d971e9c0fdd860f9269c22d7e3169dbat txn 0xed709eac284d5a15f0ca54fa6c9f16767d29837a55a19e6c45db43909b9ee378
 Latest 25 transactions from a total of 375 transactions

TxHash Age From To Value [TxFee]
0x4eee7fe290c785b6c3f04f504c406084ad4b53e2a2e480dbc4a861fd22647c8b18 days 10 hrs ago0x407813116ada2893b5bcb1c91056674c2cae956a  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.00117915
0x282f259f676112c685316cf52162cf70e9473a70bf3e7a84b26491232155b92f18 days 10 hrs ago0xb66f0ce54d672bc672492933fd5a2b0b08694e51  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.001581903
0x9de6e510a8413932864364aeda21b60d7ec456ec8b5fd57bfc380e3df76988eb18 days 10 hrs ago0xee6ff3d81d7400d3d7cf563896d69432472d0716  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.002196903
0xa7dbfbb218371bc89b6600404c2f587ed663599cc850620717ca30b82e2fe9a221 days 14 hrs ago0xb66f0ce54d672bc672492933fd5a2b0b08694e51  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.0010691
0x34a779727d2c260a95e57d46baf2f29aab0ab6d9f3508915d58c7aed0d19e76064 days 14 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.00030764
0x749e51e0e91737da4046feae1918d63461f943d2dba4d1c3dc2283ffb2c900e764 days 14 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.00038455
0x8eb1dadc333af6f3219b380e516d9c05155de1b690e18678b7ff08b95e05405865 days 10 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.002191655
0x91b3ac6a9b701439f5fa3e087978484b9b481e9461227cdd923ab8b24c1b891f82 days 11 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.00321114
0x3e0c6ddef33a63b2ec954386685cdc428d5816e49c195464476f93cd64cf9f6b82 days 12 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.00231114
0xc9b11c3f9e1a78c0436dbc3ed115157573eb8e86e8a3379fb06cea64f020784a83 days 20 hrs ago0xb3397254a50ff18986ecb50e772bf1aa78c43736  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.002507895
0x65fc806b04b7ca9be703e2a3ffd07c77525852dabeb4dfddd3f7220c60d290ac87 days 17 hrs ago0x7e9ab874f02eed6105c1dcba2a800497cfdbcc72  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.001311822
0xcccd75dc4a2834a5224d42506bc282361a4013b26247b9c66f52bc96e947960487 days 18 hrs ago0x7e9ab874f02eed6105c1dcba2a800497cfdbcc72  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.001598
0x34e58344e4efb996eaba6ec7039667dd9c8b21609828686b20b5cc01192c00fb87 days 18 hrs ago0x7e9ab874f02eed6105c1dcba2a800497cfdbcc72  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.0025
0xa696aaa7d9a181fbdf5967938b6c959ad0bb8c7a1390eec051a7beaaa1f7f50287 days 19 hrs ago0x7e9ab874f02eed6105c1dcba2a800497cfdbcc72  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.0025
0xd5513157fef7cae4e8e2b010477eee7666c684f47b103981b81f1e798097339189 days 12 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.00231114
0x215b6c76d88c76a82ac68a8ddc81ecea8caeee5a34a493b83bfb46824c1af9df91 days 10 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.00320346
0x8f90a17eaa7483e849c63d72f371c1a48e136599d66f57718c742b4bf3e9472c96 days 11 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.00231114
0xbca1979a8ac9b53169180d1e991b3b75ab7ed44de56fbb0e76169a6de2b40f42103 days 11 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.00154076
0xf1997b1e9d22b4aec7292d80bbf7849e6b784a6e33879046037e652568a7ed7d105 days 13 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.00321498
0xc3dc914af78a0b8d7b6663e2d9f579298820916d671c3e4d7301193bb6a52c19105 days 13 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.00321498
0x740e9875724899d9695f0f73c2b31671838e270c9273d8c7b4b0ca24a480b878105 days 13 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.00144
0x5ea553037a285690b71ef77ee7fc73f8bafed686b777aad74006b7012df7a34e105 days 13 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.002571984
0x0f17dc0bf7b2fd1ff4b29befc3e4928531d99d0859e52f6cef754da3cf1093bc105 days 13 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.002571984
0x830127ac84878d66f70e27ade250fda31fabd75a79e9b545be3eb421410c14ca106 days 11 hrs ago0x9d26827bb0994eec3c34753d6e4ebdb5074bab0c  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.002571984
0xac1b36389d1922c22173bf24b8452a900e686ac3394100fddae2a9a3f46aa0c1106 days 15 hrs ago0x5e9ccae2ebce4f0a30b926eba81883491802b587  IN   0x11d635bbba3f9b8f7c9b91ca9f315a2207cb5ad50 Ether0.002503735
[ Download CSV Export  ] 
 Internal Transactions as a result of Contract Execution
View All
ParentTxHash Block Age From To Value
Warning: The Compiled Contract might be susceptible to ExpExponentCleanup (medium/high-severity), EventStructWrongData (very low-severity), NestedArrayFunctionCallDecoder (medium-severity) SolidityCompiler Bugs.

Contract Source Code Verified (Exact Match)
Contract Name: dHealthToken
Compiler Text: v0.4.18+commit.9cf6e910
Optimization Enabled: No
Runs (Optimiser):  200



  Contract Source Code   Find Similiar Contracts

pragma solidity ^0.4.18;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 * Library easily handles the cases of overflow as well as underflow. 
 * Also ensures that balance does nto get naegative
 */
library SafeMath {
	// multiplies two values safely and returns result
	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;
	}

	// devides two values safely and returns result
	function div(uint256 a, uint256 b) internal pure returns (uint256) {
		// assert(b > 0); // Solidity automatically throws when dividing by 0
		uint256 c = a / b;
		// assert(a == b * c + a % b); // There is no case in which this doesn't hold
		return c;
	}

	// subtracts two values safely and returns result
	function sub(uint256 a, uint256 b) internal pure returns (uint256) {
		assert(b <= a);
		return a - b;
	}

	// adds two values safely and returns result
	function add(uint256 a, uint256 b) internal pure returns (uint256) {
		uint256 c = a + b;
		assert(c >= a);
		return c;
	}
}


/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
	address public owner;

	// Event to log whenever the ownership is tranferred
	event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


	/**
	 * @dev The Ownable constructor sets the original `owner` of the contract to the sender
	 * account.
	 */
	function Ownable() public {
		owner = msg.sender;
	}


	/**
	 * @dev Throws if called by any account other than the owner.
	 */
	modifier onlyOwner() {
		require(msg.sender == owner);
		_;
	}


	/**
	 * @dev Allows the current owner to transfer control of the contract to a newOwner.
	 * @param newOwner The address to transfer ownership to.
	 */
	function transferOwnership(address newOwner) public onlyOwner {
		require(newOwner != address(0));
		OwnershipTransferred(owner, newOwner);
		owner = newOwner;
	}

}

/**
 * @title Timestamped
 * @dev The Timestamped contract has sets dummy timestamp for method calls
 */
contract Timestamped is Ownable {
	uint256 public ts = 0;
	uint256 public plus = 0;

	function getBlockTime() public view returns (uint256) {
		if(ts > 0) {
			return ts + plus;
		} else {
			return block.timestamp + plus; 
		}
	}
}

/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
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, bytes data);
}


/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
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);
}

/**
 * @title Basic token
 * @dev Basic version of StandardToken, with no allowances.
 */
contract BasicToken is ERC20Basic {
	using SafeMath for uint256;

	mapping(address => uint256) balances;

	/**
	* @dev transfer token for a specified address
	* @param _to The address to transfer to.
	* @param _value The amount to be transferred.
	*/
	function transfer(address _to, uint256 _value) public returns (bool) {
		require(_to != address(0));
		require(_value <= balances[msg.sender]);

		// SafeMath.sub will throw if there is not enough balance.
		balances[msg.sender] = balances[msg.sender].sub(_value);
		balances[_to] = balances[_to].add(_value);

		bytes memory empty;
		Transfer(msg.sender, _to, _value, empty);
		return true;
	}

	/**
	* @dev Gets the balance of the specified address.
	* @param _owner The address to query the the balance of.
	* @return An uint256 representing the amount owned by the passed address.
	*/
	function balanceOf(address _owner) public view returns (uint256 balance) {
		return balances[_owner];
	}

}


/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * @dev https://github.com/ethereum/EIPs/issues/20
 */
contract StandardToken is ERC20, BasicToken {

	// tracks the allowance of address. 
	mapping (address => mapping (address => uint256)) internal allowed;


	/**
	 * @dev Transfer tokens from one address to another
	 * @param _from address The address which you want to send tokens from
	 * @param _to address The address which you want to transfer to
	 * @param _value uint256 the amount of tokens to be transferred
	 */
	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);

		bytes memory empty;
		Transfer(_from, _to, _value, empty);
		return true;
	}

	/**
	 * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
	 *
	 * Beware that changing an allowance with this method brings the risk that someone may use both the old
	 * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
	 * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
	 * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
	 * @param _spender The address which will spend the funds.
	 * @param _value The amount of tokens to be spent.
	 */
	function approve(address _spender, uint256 _value) public returns (bool) {
		allowed[msg.sender][_spender] = _value;
		Approval(msg.sender, _spender, _value);
		return true;
	}

	/**
	 * @dev Function to check the amount of tokens that an owner allowed to a spender.
	 * @param _owner address The address which owns the funds.
	 * @param _spender address The address which will spend the funds.
	 * @return A uint256 specifying the amount of tokens still available for the spender.
	 */
	function allowance(address _owner, address _spender) public view returns (uint256) {
		return allowed[_owner][_spender];
	}

	/**
	 * @dev Increase the amount of tokens that an owner allowed to a spender.
	 *
	 * approve should be called when allowed[_spender] == 0. To increment
	 * allowed value is better to use this function to avoid 2 calls (and wait until
	 * the first transaction is mined)
	 * From MonolithDAO Token.sol
	 * @param _spender The address which will spend the funds.
	 * @param _addedValue The amount of tokens to increase the allowance by.
	 */
	function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
		allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
		Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
		return true;
	}

	/**
	 * @dev Decrease the amount of tokens that an owner allowed to a spender.
	 *
	 * approve should be called when allowed[_spender] == 0. To decrement
	 * allowed value is better to use this function to avoid 2 calls (and wait until
	 * the first transaction is mined)
	 * From MonolithDAO Token.sol
	 * @param _spender The address which will spend the funds.
	 * @param _subtractedValue The amount of tokens to decrease the allowance by.
	 */
	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);
		}
		Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
		return true;
	}

}

/**
 * @title ERC23Receiver interface
 * @dev see https://github.com/ethereum/EIPs/issues/223
 */
contract ERC223Receiver {
	 
	struct TKN {
		address sender;
		uint256 value;
		bytes data;
		bytes4 sig;
	}
	
	/**
	 * @dev Fallback function. Our ICO contract should implement this contract to receve ERC23 compatible tokens.
	 * ERC23 protocol checks if contract has implemented this fallback method or not. 
	 * If this method is not implemented then tokens are not sent.
	 * This method is introduced to avoid loss of tokens 
	 *
	 * @param _from The address which will transfer the tokens.
	 * @param _value Amount of tokens received.
	 * @param _data Data sent along with transfer request.
	 */
	function tokenFallback(address _from, uint256 _value, bytes _data) public pure {
		TKN memory tkn;
		tkn.sender = _from;
		tkn.value = _value;
		tkn.data = _data;
		// uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
		// tkn.sig = bytes4(u);
	  
		/* tkn variable is analogue of msg variable of Ether transaction
		*  tkn.sender is person who initiated this token transaction   (analogue of msg.sender)
		*  tkn.value the number of tokens that were sent   (analogue of msg.value)
		*  tkn.data is data of token transaction   (analogue of msg.data)
		*  tkn.sig is 4 bytes signature of function
		*  if data of token transaction is a function execution
		*/
	}
}

/**
 * @title ERC23 interface
 * @dev see https://github.com/ethereum/EIPs/issues/223
 */
contract ERC223 {
	uint256 public totalSupply;
	function balanceOf(address who) public view returns (uint256);
	function transfer(address to, uint256 value) public returns (bool);
	function transfer(address to, uint256 value, bytes data) public returns (bool);
	function transfer(address to, uint256 value, bytes data, string custom_fallback) public returns (bool);
	event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
}

/**
 * @title Standard ERC223Token token
 *
 * @dev Implementation of the ERC23 token.
 * @dev https://github.com/ethereum/EIPs/issues/223
 */

contract ERC223Token is ERC223, StandardToken {
	using SafeMath for uint256;

	/**
	 * @dev Function that is called when a user or another contract wants to transfer funds .
	 * This is method where you can supply fallback function name and that function will be triggered.
	 * This method is added as part of ERC23 standard
	 *
	 * @param _to The address which will receive the tokens.
	 * @param _value Amount of tokens received.
	 * @param _data Data sent along with transfer request.
	 * @param _custom_fallback Name of the method which should be called after transfer happens. If this method does not exists on contract then transaction will fail
	 */
	function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) public returns (bool success) {
		// check if receiving is contract
		if(isContract(_to)) {
			// validate the address and balance
			require(_to != address(0));
			require(_value <= balances[msg.sender]);

			// SafeMath.sub will throw if there is not enough balance.
			balances[msg.sender] = balances[msg.sender].sub(_value);
			balances[_to] = balances[_to].add(_value);
	
			// invoke custom fallback function			
			assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
			Transfer(msg.sender, _to, _value, _data);
			return true;
		}
		else {
			// receiver is not a contract so perform normal transfer to address
			return transferToAddress(_to, _value, _data);
		}
	}
  

	/**
	 * @dev Function that is called when a user or another contract wants to transfer funds .
	 * You can pass extra data which can be tracked in event.
	 * This method is added as part of ERC23 standard
	 *
	 * @param _to The address which will receive the tokens.
	 * @param _value Amount of tokens received.
	 * @param _data Data sent along with transfer request.
	 */
	function transfer(address _to, uint256 _value, bytes _data) public returns (bool success) {
		// check if receiver is contract address
		if(isContract(_to)) {
			// invoke transfer request to contract
			return transferToContract(_to, _value, _data);
		}
		else {
			// invoke transfer request to normal user wallet address
			return transferToAddress(_to, _value, _data);
		}
	}
  
	/**
	 * @dev Standard function transfer similar to ERC20 transfer with no _data .
	 * Added due to backwards compatibility reasons .
	 *
	 * @param _to The address which will receive the tokens.
	 * @param _value Amount of tokens received.
	 */
	function transfer(address _to, uint256 _value) public returns (bool success) {
		//standard function transfer similar to ERC20 transfer with no _data
		//added due to backwards compatibility reasons
		bytes memory empty;

		// check if receiver is contract address
		if(isContract(_to)) {
			// invoke transfer request to contract
			return transferToContract(_to, _value, empty);
		}
		else {
			// invoke transfer request to normal user wallet address
			return transferToAddress(_to, _value, empty);
		}
	}

	/**
	 * @dev assemble the given address bytecode. If bytecode exists then the _addr is a contract.
	 *
	 * @param _addr The address which need to be checked if contract address or wallet address
	 */
	function isContract(address _addr) private view returns (bool is_contract) {
		uint256 length;
		assembly {
			//retrieve the size of the code on target address, this needs assembly
			length := extcodesize(_addr)
		}
		return (length > 0);
	}

	/**
	 * @dev Function that is called when transaction target is an address. This is private method.
	 *
	 * @param _to The address which will receive the tokens.
	 * @param _value Amount of tokens received.
	 * @param _data Data sent along with transfer request.
	 */
	function transferToAddress(address _to, uint256 _value, bytes _data) private returns (bool success) {
		// validate the address and balance
		require(_to != address(0));
		require(_value <= balances[msg.sender]);

		// SafeMath.sub will throw if there is not enough balance.
		balances[msg.sender] = balances[msg.sender].sub(_value);
		balances[_to] = balances[_to].add(_value);

		// Log the transfer event
		Transfer(msg.sender, _to, _value, _data);
		return true;
	}
  
	/**
	 * @dev Function that is called when transaction target is a contract. This is private method.
	 *
	 * @param _to The address which will receive the tokens.
	 * @param _value Amount of tokens received.
	 * @param _data Data sent along with transfer request.
	 */
	function transferToContract(address _to, uint256 _value, bytes _data) private returns (bool success) {
		// validate the address and balance
		require(_to != address(0));
		require(_value <= balances[msg.sender]);

		// SafeMath.sub will throw if there is not enough balance.
		balances[msg.sender] = balances[msg.sender].sub(_value);
		balances[_to] = balances[_to].add(_value);

		// call fallback function of contract
		ERC223Receiver receiver = ERC223Receiver(_to);
		receiver.tokenFallback(msg.sender, _value, _data);
		
		// Log the transfer event
		Transfer(msg.sender, _to, _value, _data);
		return true;
	}
}

/**
* @title dHealthToken
* @dev Very simple ERC23 Token example, where all tokens are pre-assigned to the creator.
*/
contract dHealthToken is ERC223Token, Ownable {

	string public constant name = "dHealth";
	string public constant symbol = "dHt";
	uint256 public constant decimals = 18;

	uint256 constant INITIAL_SUPPLY = 500000000 * 1E18;
	
	/**
	* @dev Constructor that gives msg.sender all of existing tokens.
	*/
	function dHealthToken() public {
		totalSupply = INITIAL_SUPPLY;
		balances[msg.sender] = INITIAL_SUPPLY;
	}

	/**
	* @dev if ether is sent to this address, send it back.
	*/
	function() public payable {
		revert();
	}
}

/**
 * @title dHealthTokenDistributor
 * @dev The Distributor contract has an list of team member addresses and their share, 
 * and provides method which can be called to distribute available smart contract balance across users.
 */
contract dHealthTokenDistributor is Ownable, Timestamped {
	using SafeMath for uint256;

	// The token being sold, this holds reference to main token contract
	dHealthToken public token;

	// token vesting contract addresses
	address public communityContract;
	address public foundersContract;
	address public technicalContract;
	address public managementContract;

	// token vesting contract amounts
	uint256 public communityAmount;
	uint256 public foundersAmount;
	uint256 public technicalAmount;
	uint256 public managementAmount;

	/**
	* @dev Constructor that initializes team and share
	*/
	function dHealthTokenDistributor(address _token, address _communityContract, address _foundersContract, address _technicalContract, address _managementContract) public {
		// set token
		token = dHealthToken(_token);

		// initialize contract addresses
		communityContract = _communityContract;
		foundersContract = _foundersContract;
		technicalContract = _technicalContract;
		managementContract = _managementContract;

		// initialize precentage share
		communityAmount = 10000000 * 1E18;
		foundersAmount = 15000000 * 1E18;
		technicalAmount = 55000000 * 1E18;
		managementAmount = 60000000 * 1E18;
	}

	/**
	* @dev distribute funds.
	*/	
	function distribute() onlyOwner public payable {
		bytes memory empty;

		// distribute funds to community 		
		token.transfer(communityContract, communityAmount, empty);

		// distribute funds to founders 		
		token.transfer(foundersContract, foundersAmount, empty);

		// distribute funds to technical 		
		token.transfer(technicalContract, technicalAmount, empty);

		// distribute funds to management 		
		token.transfer(managementContract, managementAmount, empty);
	}
}

/**
 * @title dHealthEtherDistributor
 * @dev The Distributor contract has an list of team member addresses and their share, 
 * and provides method which can be called to distribute available smart contract balance across users.
 */
contract dHealthEtherDistributor is Ownable, Timestamped {
	using SafeMath for uint256;

	address public projectContract;	
	address public technologyContract;	
	address public founderContract;	

	uint256 public projectShare;
	uint256 public technologyShare;
	uint256 public founderShare;

	/**
	* @dev Constructor that initializes team and share
	*/
	function dHealthEtherDistributor(address _projectContract, address _technologyContract, address _founderContract) public {

		// initialize contract addresses
		projectContract = _projectContract;	
		technologyContract = _technologyContract;	
		founderContract = _founderContract;	

		// initialize precentage share
		projectShare = 72;
		technologyShare = 18;
		founderShare = 10;
	}

	/**
	* @dev distribute funds.
	*/	
	function distribute() onlyOwner public payable {
		uint256 balance = this.balance;
		
		// distribute funds to founders 		
		uint256 founderPart = balance.mul(founderShare).div(100);
		if(founderPart > 0) {
			founderContract.transfer(founderPart);
		}

		// distribute funds to technology 		
		uint256 technologyPart = balance.mul(technologyShare).div(100);
		if(technologyPart > 0) {
			technologyContract.transfer(technologyPart);
		}

		// distribute left balance to project
		uint256 projectPart = this.balance;
		if(projectPart > 0) {
			projectContract.transfer(projectPart);
		}
	}
}

/**
* @title dHealthTokenIncentive
* @dev This is token incentive contract it receives tokens and holds it for certain period of time
*/
contract dHealthTokenIncentive is dHealthTokenDistributor, ERC223Receiver {
	using SafeMath for uint256;

	// The token being sold, this holds reference to main token contract
	dHealthToken public token;

	// amount of token on hold
	uint256 public maxTokenForHold = 140000000 * 1E18;

	// contract timeout 
	uint256 public contractTimeout = 1555286400; // Monday, 15 April 2019 00:00:00

	/**
	* @dev Constructor that initializes vesting contract with contract addresses in parameter
	*/
	function dHealthTokenIncentive(address _token, address _communityContract, address _foundersContract, address _technicalContract, address _managementContract) 
		dHealthTokenDistributor(_token, _communityContract, _foundersContract, _technicalContract, _managementContract)
		public {
		// set token
		token = dHealthToken(_token);
	}

	/**
	* @dev Method called by owner of contract to withdraw all tokens after timeout has reached
	*/
	function withdraw() onlyOwner public {
		require(contractTimeout <= getBlockTime());
		
		// send remaining tokens back to owner.
		uint256 tokens = token.balanceOf(this); 
		bytes memory empty;
		token.transfer(owner, tokens, empty);
	}
}

/**
* @title dHealthTokenGrowth
* @dev This is token growth contract it receives tokens and holds it for certain period of time
*/
contract dHealthTokenGrowth is Ownable, ERC223Receiver, Timestamped {
	using SafeMath for uint256;

	// The token being sold, this holds reference to main token contract
	dHealthToken public token;

	// amount of token on hold
	uint256 public maxTokenForHold = 180000000 * 1E18;

	// exchanges wallet address
	address public exchangesWallet;
	uint256 public exchangesTokens = 45000000 * 1E18;
	uint256 public exchangesLockEndingAt = 1523750400; // Sunday, 15 April 2018 00:00:00
	bool public exchangesStatus = false;

	// countries wallet address
	address public countriesWallet;
	uint256 public countriesTokens = 45000000 * 1E18;
	uint256 public countriesLockEndingAt = 1525132800; // Tuesday, 1 May 2018 00:00:00
	bool public countriesStatus = false;

	// acquisitions wallet address
	address public acquisitionsWallet;
	uint256 public acquisitionsTokens = 45000000 * 1E18;
	uint256 public acquisitionsLockEndingAt = 1526342400; // Tuesday, 15 May 2018 00:00:00
	bool public acquisitionsStatus = false;

	// coindrops wallet address
	address public coindropsWallet;
	uint256 public coindropsTokens = 45000000 * 1E18;
	uint256 public coindropsLockEndingAt = 1527811200; // Friday, 1 June 2018 00:00:00
	bool public coindropsStatus = false;

	// contract timeout 
	uint256 public contractTimeout = 1555286400; // Monday, 15 April 2019 00:00:00

	/**
	* @dev Constructor that initializes vesting contract with contract addresses in parameter
	*/
	function dHealthTokenGrowth(address _token, address _exchangesWallet, address _countriesWallet, address _acquisitionsWallet, address _coindropsWallet) public {
		// set token
		token = dHealthToken(_token);

		// setup wallet addresses
		exchangesWallet = _exchangesWallet;
		countriesWallet = _countriesWallet;
		acquisitionsWallet = _acquisitionsWallet;
		coindropsWallet = _coindropsWallet;
	}

	/**
	* @dev Method called by anyone to withdraw funds to exchanges wallet after locking period
	*/
	function withdrawExchangesToken() public {
		// check if time has reached
		require(exchangesLockEndingAt <= getBlockTime());
		// ensure that tokens are not already transferred
		require(exchangesStatus == false);
		
		// transfer tokens to wallet and change status to prevent double transfer		
		bytes memory empty;
		token.transfer(exchangesWallet, exchangesTokens, empty);
		exchangesStatus = true;
	}

	/**
	* @dev Method called by anyone to withdraw funds to countries wallet after locking period
	*/
	function withdrawCountriesToken() public {
		// check if time has reached
		require(countriesLockEndingAt <= getBlockTime());
		// ensure that tokens are not already transferred
		require(countriesStatus == false);
		
		// transfer tokens to wallet and change status to prevent double transfer		
		bytes memory empty;
		token.transfer(countriesWallet, countriesTokens, empty);
		countriesStatus = true;
	}

	/**
	* @dev Method called by anyone to withdraw funds to acquisitions wallet after locking period
	*/
	function withdrawAcquisitionsToken() public {
		// check if time has reached
		require(acquisitionsLockEndingAt <= getBlockTime());
		// ensure that tokens are not already transferred
		require(acquisitionsStatus == false);
		
		// transfer tokens to wallet and change status to prevent double transfer		
		bytes memory empty;
		token.transfer(acquisitionsWallet, acquisitionsTokens, empty);
		acquisitionsStatus = true;
	}

	/**
	* @dev Method called by anyone to withdraw funds to coindrops wallet after locking period
	*/
	function withdrawCoindropsToken() public {
		// check if time has reached
		require(coindropsLockEndingAt <= getBlockTime());
		// ensure that tokens are not already transferred
		require(coindropsStatus == false);
		
		// transfer tokens to wallet and change status to prevent double transfer		
		bytes memory empty;
		token.transfer(coindropsWallet, coindropsTokens, empty);
		coindropsStatus = true;
	}

	/**
	* @dev Method called by owner of contract to withdraw all tokens after timeout has reached
	*/
	function withdraw() onlyOwner public {
		require(contractTimeout <= getBlockTime());
		
		// send remaining tokens back to owner.
		uint256 tokens = token.balanceOf(this); 
		bytes memory empty;
		token.transfer(owner, tokens, empty);
	}
}


/**
* @title dHealthTokenSale
* @dev This is ICO Contract. 
* This class accepts the token address as argument to talk with contract.
* Once contract is deployed, funds are transferred to ICO smart contract address and then distributed with investor.
* Sending funds to this ensures that no more than desired tokens are sold.
*/
contract dHealthTokenSale is dHealthEtherDistributor, ERC223Receiver {
	using SafeMath for uint256;

	// The token being sold, this holds reference to main token contract
	dHealthToken public token;

	// amount of token to be sold on sale
	uint256 public maxTokenForSale = 180000000 * 1E18;

	// timestamp when phase 1 starts
	uint256 public phase1StartingAt = 1516924800; // Friday, 26 January 2018 00:00:00
	uint256 public phase1EndingAt = 1518134399; // Thursday, 8 February 2018 23:59:59
	uint256 public phase1MaxTokenForSale = maxTokenForSale * 1 / 3;
	uint256 public phase1TokenPriceInEth = 0.0005 ether;
	uint256 public phase1TokenSold = 0;

	// timestamp when phase 2 starts
	uint256 public phase2StartingAt = 1518134400; // Friday, 9 February 2018 00:00:00
	uint256 public phase2EndingAt = 1519343999; // Thursday, 22 February 2018 23:59:59
	uint256 public phase2MaxTokenForSale = maxTokenForSale * 2 / 3;
	uint256 public phase2TokenPriceInEth = 0.000606060606 ether;
	uint256 public phase2TokenSold = 0;

	// timestamp when phase 3 starts
	uint256 public phase3StartingAt = 1519344000; // Friday, 23 February 2018 00:00:00
	uint256 public phase3EndingAt = 1520553599; // Thursday, 8 March 2018 23:59:59
	uint256 public phase3MaxTokenForSale = maxTokenForSale;
	uint256 public phase3TokenPriceInEth = 0.000769230769 ether;
	uint256 public phase3TokenSold = 0;

	// contract timeout to initiate left funds and token transfer
	uint256 public contractTimeout = 1520553600; // Friday, 9 March 2018 00:00:00

	// growth contract address
	address public growthContract;

	// maximum ether invested per transaction
	uint256 public maxEthPerTransaction = 1000 ether;

	// minimum ether invested per transaction
	uint256 public minEthPerTransaction = 0.01 ether;

	// amount of token sold so far
	uint256 public totalTokenSold;

	// amount of ether raised in sale
	uint256 public totalEtherRaised;

	// ether raised per wallet
	mapping(address => uint256) public etherRaisedPerWallet;

	// is contract close and ended
	bool public isClose = false;

	// is contract paused
	bool public isPaused = false;

	// token purchsae event
	event TokenPurchase(address indexed _purchaser, address indexed _beneficiary, uint256 _value, uint256 _amount, uint256 _timestamp);

	// manual transfer by admin for external purchase
	event TransferManual(address indexed _from, address indexed _to, uint256 _value, string _message);

	/**
	* @dev Constructor that initializes token contract with token address in parameter
	*/
	function dHealthTokenSale(address _token, address _projectContract, address _technologyContract, address _founderContract, address _growthContract)
		dHealthEtherDistributor(_projectContract, _technologyContract, _founderContract)
		public {
		// set token
		token = dHealthToken(_token);

		// set growth contract address
		growthContract = _growthContract;
	}

	/**
	 * @dev Function that validates if the purchase is valid by verifying the parameters
	 *
	 * @param value Amount of ethers sent
	 * @param amount Total number of tokens user is trying to buy.
	 *
	 * @return checks various conditions and returns the bool result indicating validity.
	 */
	function validate(uint256 value, uint256 amount) internal constant returns (bool) {
		// check if timestamp and amount is falling in the range
		bool validTimestamp = false;
		bool validAmount = false;

		// check if phase 1 is running	
		if(phase1StartingAt <= getBlockTime() && getBlockTime() <= phase1EndingAt) {
			// check if tokens is falling in timerange
			validTimestamp = true;

			// check if token amount is falling in limit
			validAmount = phase1MaxTokenForSale.sub(totalTokenSold) >= amount;
		}

		// check if phase 2 is running	
		if(phase2StartingAt <= getBlockTime() && getBlockTime() <= phase2EndingAt) {
			// check if tokens is falling in timerange
			validTimestamp = true;

			// check if token amount is falling in limit
			validAmount = phase2MaxTokenForSale.sub(totalTokenSold) >= amount;
		}

		// check if phase 3 is running	
		if(phase3StartingAt <= getBlockTime() && getBlockTime() <= phase3EndingAt) {
			// check if tokens is falling in timerange
			validTimestamp = true;

			// check if token amount is falling in limit
			validAmount = phase3MaxTokenForSale.sub(totalTokenSold) >= amount;
		}

		// check if value of the ether is valid
		bool validValue = value != 0;

		// check if the tokens available in contract for sale
		bool validToken = amount != 0;

		// validate if all conditions are met
		return validTimestamp && validAmount && validValue && validToken && !isClose && !isPaused;
	}

	function calculate(uint256 value) internal constant returns (uint256) {
		uint256 amount = 0;
			
		// check if phase 1 is running	
		if(phase1StartingAt <= getBlockTime() && getBlockTime() <= phase1EndingAt) {
			// calculate the amount of tokens
			amount = value.mul(1E18).div(phase1TokenPriceInEth);
		}

		// check if phase 2 is running	
		if(phase2StartingAt <= getBlockTime() && getBlockTime() <= phase2EndingAt) {
			// calculate the amount of tokens
			amount = value.mul(1E18).div(phase2TokenPriceInEth);
		}

		// check if phase 3 is running	
		if(phase3StartingAt <= getBlockTime() && getBlockTime() <= phase3EndingAt) {
			// calculate the amount of tokens
			amount = value.mul(1E18).div(phase3TokenPriceInEth);
		}

		return amount;
	}

	function update(uint256 value, uint256 amount) internal returns (bool) {

		// update the state to log the sold tokens and raised ethers.
		totalTokenSold = totalTokenSold.add(amount);
		totalEtherRaised = totalEtherRaised.add(value);
		etherRaisedPerWallet[msg.sender] = etherRaisedPerWallet[msg.sender].add(value);

		// check if phase 1 is running	
		if(phase1StartingAt <= getBlockTime() && getBlockTime() <= phase1EndingAt) {
			// add tokens to phase1 counts
			phase1TokenSold = phase1TokenSold.add(amount);
		}

		// check if phase 2 is running	
		if(phase2StartingAt <= getBlockTime() && getBlockTime() <= phase2EndingAt) {
			// add tokens to phase2 counts
			phase2TokenSold = phase2TokenSold.add(amount);
		}

		// check if phase 3 is running	
		if(phase3StartingAt <= getBlockTime() && getBlockTime() <= phase3EndingAt) {
			// add tokens to phase3 counts
			phase3TokenSold = phase3TokenSold.add(amount);
		}
	}

	/**
	 * @dev Default fallback method which will be called when any ethers are sent to contract
	 */
	function() public payable {
		buy(msg.sender);
	}

	/**
	 * @dev Function that is called either externally or by default payable method
	 *
	 * @param beneficiary who should receive tokens
	 */
	function buy(address beneficiary) public payable {
		require(beneficiary != address(0));

		// amount of ethers sent
		uint256 value = msg.value;

		// throw error if not enough ethers sent
		require(value >= minEthPerTransaction);

		// refund the extra ethers if sent more than allowed
		if(value > maxEthPerTransaction) {
			// more ethers are sent so refund extra
			msg.sender.transfer(value.sub(maxEthPerTransaction));
			value = maxEthPerTransaction;
		}
		
		// calculate tokens
		uint256 tokens = calculate(value);

		// validate the purchase
		require(validate(value , tokens));

		// update current state 
		update(value , tokens);
		
		// transfer tokens from contract balance to beneficiary account. calling ERC223 method
		bytes memory empty;
		token.transfer(beneficiary, tokens, empty);
		
		// log event for token purchase
		TokenPurchase(msg.sender, beneficiary, value, tokens, now);
	}

	/**
	* @dev transmit token for a specified address. 
	* This is owner only method and should be called using web3.js if someone is trying to buy token using bitcoin or any other altcoin.
	* 
	* @param _to The address to transmit to.
	* @param _value The amount to be transferred.
	* @param _message message to log after transfer.
	*/
	function transferManual(address _to, uint256 _value, string _message) onlyOwner public returns (bool) {
		require(_to != address(0));

		// transfer tokens manually from contract balance
		token.transfer(_to , _value);
		TransferManual(msg.sender, _to, _value, _message);
		return true;
	}

	/**
	* @dev sendToGrowthContract  
	* This will send remaining tokens to growth contract
	*/	
	function sendToGrowthContract() onlyOwner public {
		require(contractTimeout <= getBlockTime());

		// send remaining tokens to growth contract.
		uint256 tokens = token.balanceOf(this); 
		bytes memory empty;
		token.transfer(growthContract, tokens, empty);
	}

	/**
	* @dev sendToVestingContract  
	* This will transfer any available ethers to vesting contracts
	*/	
	function sendToVestingContract() onlyOwner public {
		// distribute funds 
		distribute();
	}

	/**
	* @dev withdraw funds and tokens 
	* This will send remaining token balance to growth contract
	* This will distribute available funds across team members
	*/	
	function withdraw() onlyOwner public {
		require(contractTimeout <= getBlockTime());

		// send remaining tokens to growth contract.
		uint256 tokens = token.balanceOf(this); 
		bytes memory empty;
		token.transfer(growthContract, tokens, empty);

		// distribute funds 
		distribute();
	}

	/**
	* @dev close contract 
	* This will mark contract as closed
	*/	
	function close() onlyOwner public {
		// mark the flag to indicate closure of the contract
		isClose = true;
	}

	/**
	* @dev pause contract 
	* This will mark contract as paused
	*/	
	function pause() onlyOwner public {
		// mark the flag to indicate pause of the contract
		isPaused = true;
	}

	/**
	* @dev resume contract 
	* This will mark contract as resumed
	*/	
	function resume() onlyOwner public {
		// mark the flag to indicate resume of the contract
		isPaused = false;
	}
}

/**
* @title dHealthEtherVesting
* @dev This is vesting contract it receives funds and those are used to release funds to fixed address
*/
contract dHealthEtherVesting is Ownable, Timestamped {
	using SafeMath for uint256;

	// wallet address which will receive funds on pay
	address public wallet;

	// timestamp when vesting contract starts, this timestamp matches with sale contract
	uint256 public startingAt = 1516924800; // Friday, 26 January 2018 00:00:00

	// timestamp when vesting ends
	uint256 public endingAt = startingAt + 540 days;

	// how many % of ethers to vest on each call
	uint256 public vestingAmount = 20;

	// timestamp when vesting starts
	uint256 public vestingPeriodLength = 30 days;

	// time after which owner can withdraw all available funds
	uint256 public contractTimeout = startingAt + 2 years;

	// mapping that defines vesting structure
	struct VestingStruct {
		uint256 period; 
		bool status;
		address wallet;
		uint256 amount;
		uint256 timestamp;
	}

	// vesting that tracks vestings done against the period.
	mapping (uint256 => VestingStruct) public vestings;

	// Event to log whenever the payment is done
	event Payouts(uint256 indexed period, bool status, address wallet, uint256 amount, uint256 timestamp);

	/**
	* @dev Constructor that does nothing 
	*/
	function dHealthEtherVesting(address _wallet) public {
		wallet = _wallet;
	}

	/**
	* @dev default payable method to receive funds
	*/
	function() public payable {
		
	}

	/**
	* @dev Method called by owner of contract to withdraw funds
	*/
	function pay(uint256 percentage) public payable {
		// requested amount should always be less than vestingAmount variable
		percentage = percentage <= vestingAmount ? percentage : vestingAmount;

		// calculate amount allowed
		var (period, amount) = calculate(getBlockTime() , this.balance , percentage);

		// payment should not be done if period is zero
		require(period > 0);
		// payment should not be done already
		require(vestings[period].status == false);
		// wallet should not be set already.
		require(vestings[period].wallet == address(0));
		// there should be amount to pay
		require(amount > 0);

		// set period for storage
		vestings[period].period = period;
		// set status to avoid double payment
		vestings[period].status = true;
		// set wallet to track where payment was sent
		vestings[period].wallet = wallet;
		// set wallet to track how much amount sent
		vestings[period].amount = amount;
		// set timestamp of payment
		vestings[period].timestamp = getBlockTime();

		// transfer amount to wallet address
		wallet.transfer(amount);

		// log event
		Payouts(period, vestings[period].status, vestings[period].wallet, vestings[period].amount, vestings[period].timestamp);
	}

	/**
	* @dev Internal method called to current vesting period
	*/
	function getPeriod(uint256 timestamp) public view returns (uint256) {
		for(uint256 i = 1 ; i <= 18 ; i ++) {
			// calculate timestamp range
			uint256 startTime = startingAt + (vestingPeriodLength * (i - 1));
			uint256 endTime = startingAt + (vestingPeriodLength * (i));

			if(startTime <= timestamp && timestamp < endTime) {
				return i;
			}
		}

		// calculate timestamp of last period
		uint256 lastEndTime = startingAt + (vestingPeriodLength * (18));
		if(lastEndTime <= timestamp) {
			return 18;
		}

		return 0;
	}

	/**
	* @dev Internal method called to current vesting period range
	*/
	function getPeriodRange(uint256 timestamp) public view returns (uint256 , uint256) {
		for(uint256 i = 1 ; i <= 18 ; i ++) {
			// calculate timestamp range
			uint256 startTime = startingAt + (vestingPeriodLength * (i - 1));
			uint256 endTime = startingAt + (vestingPeriodLength * (i));

			if(startTime <= timestamp && timestamp < endTime) {
				return (startTime , endTime);
			}
		}

		// calculate timestamp of last period
		uint256 lastStartTime = startingAt + (vestingPeriodLength * (17));
		uint256 lastEndTime = startingAt + (vestingPeriodLength * (18));
		if(lastEndTime <= timestamp) {
			return (lastStartTime , lastEndTime);
		}

		return (0 , 0);
	}

	/**
	* @dev Internal method called to calculate withdrawal amount
	*/
	function calculate(uint256 timestamp, uint256 balance , uint256 percentage) public view returns (uint256 , uint256) {
		// find out current vesting period
		uint256 period = getPeriod(timestamp);
		if(period == 0) {
			// if period is not found then return zero;
			return (0 , 0);
		}

		// get vesting object for period
		VestingStruct memory vesting = vestings[period];	
		
		// check if payment is already done
		if(vesting.status == false) {
			// payment is not done yet
			uint256 amount;

			// if it is last month then send all remaining balance
			if(period == 18) {
				// send all
				amount = balance;
			} else {
				// calculate percentage and send
				amount = balance.mul(percentage).div(100);
			}
			
			return (period, amount);
		} else {
			// payment is already done 
			return (period, 0);
		}		
	}

	/**
	* @dev Method called by owner to change the wallet address
	*/
	function setWallet(address _wallet) onlyOwner public {
		wallet = _wallet;
	}

	/**
	* @dev Method called by owner of contract to withdraw funds after timeout has reached
	*/
	function withdraw() onlyOwner public payable {
		require(contractTimeout <= getBlockTime());
		owner.transfer(this.balance);
	}	
}


/**
* @title dHealthTokenVesting
* @dev This is vesting contract it receives tokens and those are used to release tokens to fixed address
*/
contract dHealthTokenVesting is Ownable, Timestamped {
	using SafeMath for uint256;

	// The token being sold, this holds reference to main token contract
	dHealthToken public token;

	// wallet address which will receive tokens on pay
	address public wallet;

	// amount of token to be hold
	uint256 public maxTokenForHold;

	// timestamp when vesting contract starts, this timestamp matches with sale contract
	uint256 public startingAt = 1522281600; // Thursday, 29 March 2018 00:00:00

	// timestamp when vesting ends
	uint256 public endingAt = startingAt + 540 days;

	// how many % of ethers to vest on each call
	uint256 public vestingAmount = 20;

	// timestamp when vesting starts
	uint256 public vestingPeriodLength = 30 days;

	// time after which owner can withdraw all available funds
	uint256 public contractTimeout = startingAt + 2 years;

	// mapping that defines vesting structure
	struct VestingStruct {
		uint256 period; 
		bool status;
		address wallet;
		uint256 amount;
		uint256 timestamp;
	}

	// vesting that tracks vestings done against the period.
	mapping (uint256 => VestingStruct) public vestings;

	// Event to log whenever the payment is done
	event Payouts(uint256 indexed period, bool status, address wallet, uint256 amount, uint256 timestamp);

	/**
	* @dev Constructor that initializes token contract with token address in parameter
	*/
	function dHealthTokenVesting(address _token, address _wallet, uint256 _maxTokenForHold, uint256 _startingAt) public {
		// set token
		token = dHealthToken(_token);

		// set wallet address
		wallet = _wallet;

		// set parameter specific to contract
		maxTokenForHold = _maxTokenForHold;	
		
		// setup timestamp
		startingAt = _startingAt;
		endingAt = startingAt + 540 days;
	}

	/**
	* @dev default payable method to receive funds
	*/
	function() public payable {
		
	}

	/**
	* @dev Method called by owner of contract to withdraw funds
	*/
	function pay(uint256 percentage) public {
		// requested amount should always be less than vestingAmount variable
		percentage = percentage <= vestingAmount ? percentage : vestingAmount;

		// get current token balance
		uint256 balance = token.balanceOf(this); 
		
		// calculate amount allowed
		var (period, amount) = calculate(getBlockTime() , balance , percentage);

		// payment should not be done if period is zero
		require(period > 0);
		// payment should not be done already
		require(vestings[period].status == false);
		// wallet should not be set already.
		require(vestings[period].wallet == address(0));
		// there should be amount to pay
		require(amount > 0);

		// set period for storage
		vestings[period].period = period;
		// set status to avoid double payment
		vestings[period].status = true;
		// set wallet to track where payment was sent
		vestings[period].wallet = wallet;
		// set wallet to track how much amount sent
		vestings[period].amount = amount;
		// set timestamp of payment
		vestings[period].timestamp = getBlockTime();

		// transfer amount to wallet address
		bytes memory empty;
		token.transfer(wallet, amount, empty);

		// log event
		Payouts(period, vestings[period].status, vestings[period].wallet, vestings[period].amount, vestings[period].timestamp);
	}

	/**
	* @dev Internal method called to current vesting period
	*/
	function getPeriod(uint256 timestamp) public view returns (uint256) {
		for(uint256 i = 1 ; i <= 18 ; i ++) {
			// calculate timestamp range
			uint256 startTime = startingAt + (vestingPeriodLength * (i - 1));
			uint256 endTime = startingAt + (vestingPeriodLength * (i));

			if(startTime <= timestamp && timestamp < endTime) {
				return i;
			}
		}

		// calculate timestamp of last period
		uint256 lastEndTime = startingAt + (vestingPeriodLength * (18));
		if(lastEndTime <= timestamp) {
			return 18;
		}

		return 0;
	}

	/**
	* @dev Internal method called to current vesting period range
	*/
	function getPeriodRange(uint256 timestamp) public view returns (uint256 , uint256) {
		for(uint256 i = 1 ; i <= 18 ; i ++) {
			// calculate timestamp range
			uint256 startTime = startingAt + (vestingPeriodLength * (i - 1));
			uint256 endTime = startingAt + (vestingPeriodLength * (i));

			if(startTime <= timestamp && timestamp < endTime) {
				return (startTime , endTime);
			}
		}

		// calculate timestamp of last period
		uint256 lastStartTime = startingAt + (vestingPeriodLength * (17));
		uint256 lastEndTime = startingAt + (vestingPeriodLength * (18));
		if(lastEndTime <= timestamp) {
			return (lastStartTime , lastEndTime);
		}

		return (0 , 0);
	}

	/**
	* @dev Internal method called to calculate withdrawal amount
	*/
	function calculate(uint256 timestamp, uint256 balance , uint256 percentage) public view returns (uint256 , uint256) {
		// find out current vesting period
		uint256 period = getPeriod(timestamp);
		if(period == 0) {
			// if period is not found then return zero;
			return (0 , 0);
		}

		// get vesting object for period
		VestingStruct memory vesting = vestings[period];	
		
		// check if payment is already done
		if(vesting.status == false) {
			// payment is not done yet
			uint256 amount;

			// if it is last month then send all remaining balance
			if(period == 18) {
				// send all
				amount = balance;
			} else {
				// calculate percentage and send
				amount = balance.mul(percentage).div(100);
			}
			
			return (period, amount);
		} else {
			// payment is already done 
			return (period, 0);
		}		
	}

	/**
	* @dev Method called by owner to change the wallet address
	*/
	function setWallet(address _wallet) onlyOwner public {
		wallet = _wallet;
	}

	/**
	* @dev Method called by owner of contract to withdraw funds after timeout has reached
	*/
	function withdraw() onlyOwner public payable {
		require(contractTimeout <= getBlockTime());
		
		// send remaining tokens back to owner.
		uint256 tokens = token.balanceOf(this); 
		bytes memory empty;
		token.transfer(owner, tokens, empty);
	}	
}

    Contract ABI  
[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_subtractedValue","type":"uint256"}],"name":"decreaseApproval","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"},{"name":"_data","type":"bytes"}],"name":"transfer","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_addedValue","type":"uint256"}],"name":"increaseApproval","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_spender","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"},{"name":"_data","type":"bytes"},{"name":"_custom_fallback","type":"string"}],"name":"transfer","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"spender","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"value","type":"uint256"},{"indexed":false,"name":"data","type":"bytes"}],"name":"Transfer","type":"event"}]

  Contract Creation Code Switch To Opcodes View
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

   Swarm Source:
bzzr://a8eb347fcd24462fa58c8df25e82934d80ae9fc64c324c4858d27f4419e7b2a5

 

View All
Block Age transaction Difficulty GasUsed Reward
View All
Block Age UncleNumber Difficulty GasUsed Reward
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.