Contract Source Code:
File 1 of 1 : Token
pragma solidity ^ 0.4.17;
library SafeMath {
function mul(uint a, uint b) internal pure returns(uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function 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 && c >= b);
return c;
}
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns(uint);
function allowance(address owner, address spender) public view returns(uint);
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);
}
/**
* @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 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) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() public onlyOwner whenNotPaused {
paused = true;
Pause();
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyOwner whenPaused {
paused = false;
Unpause();
}
}
// Whitelist smart contract
// This smart contract keeps list of addresses to whitelist
contract WhiteList is Ownable {
mapping(address => bool) public whiteList;
uint public totalWhiteListed; //white listed users number
event LogWhiteListed(address indexed user, uint whiteListedNum);
event LogWhiteListedMultiple(uint whiteListedNum);
event LogRemoveWhiteListed(address indexed user);
// @notice it will return status of white listing
// @return true if user is white listed and false if is not
function isWhiteListed(address _user) external view returns (bool) {
return whiteList[_user];
}
// @notice it will remove whitelisted user
// @param _contributor {address} of user to unwhitelist
function removeFromWhiteList(address _user) external onlyOwner() returns (bool) {
require(whiteList[_user] == true);
whiteList[_user] = false;
totalWhiteListed--;
LogRemoveWhiteListed(_user);
return true;
}
// @notice it will white list one member
// @param _user {address} of user to whitelist
// @return true if successful
function addToWhiteList(address _user) external onlyOwner() returns (bool) {
if (whiteList[_user] != true) {
whiteList[_user] = true;
totalWhiteListed++;
LogWhiteListed(_user, totalWhiteListed);
}
return true;
}
// @notice it will white list multiple members
// @param _user {address[]} of users to whitelist
// @return true if successful
function addToWhiteListMultiple(address[] _users) external onlyOwner() returns (bool) {
for (uint i = 0; i < _users.length; ++i) {
if (whiteList[_users[i]] != true) {
whiteList[_users[i]] = true;
totalWhiteListed++;
}
}
LogWhiteListedMultiple(totalWhiteListed);
return true;
}
}
// @note this contract can be inherited by Crowdsale and TeamAllocation contracts and
// control release of tokens through even time release based on the inputted duration time interval
contract TokenVesting is Ownable {
using SafeMath for uint;
struct TokenHolder {
uint weiReceived; // amount of ETH contributed
uint tokensToSend; // amount of tokens sent
bool refunded; // true if user has been refunded
uint releasedAmount; // amount released through vesting schedule
bool revoked; // true if right to continue vesting is revoked
}
event Released(uint256 amount, uint256 tokenDecimals);
event ContractUpdated(bool done);
uint256 public cliff; // time in when vesting should begin
uint256 public startCountDown; // time when countdown starts
uint256 public duration; // duration of period in which vesting takes place
Token public token; // token contract containing tokens
mapping(address => TokenHolder) public tokenHolders; //tokenHolder list
WhiteList public whiteList; // whitelist contract
uint256 public presaleBonus;
// @note constructor
/**
function TokenVesting(uint256 _start, uint256 _cliff, uint256 _duration) public {
require(_cliff <= _duration);
duration = _duration;
cliff = _start.add(_cliff);
startCountDown = _start;
ContractUpdated(true);
}
*/
// @notice Specify address of token contract
// @param _tokenAddress {address} address of token contract
// @return res {bool}
function initilizeVestingAndTokenAndWhiteList(Token _tokenAddress,
uint256 _start,
uint256 _cliff,
uint256 _duration,
uint256 _presaleBonus,
WhiteList _whiteList) external onlyOwner() returns(bool res) {
require(_cliff <= _duration);
require(_tokenAddress != address(0));
duration = _duration;
cliff = _start.add(_cliff);
startCountDown = _start;
token = _tokenAddress;
whiteList = _whiteList;
presaleBonus = _presaleBonus;
ContractUpdated(true);
return true;
}
// @notice Specify address of token contract
// @param _tokenAddress {address} address of token contract
// @return res {bool}
function initilizeVestingAndToken(Token _tokenAddress,
uint256 _start,
uint256 _cliff,
uint256 _duration,
uint256 _presaleBonus
) external onlyOwner() returns(bool res) {
require(_cliff <= _duration);
require(_tokenAddress != address(0));
duration = _duration;
cliff = _start.add(_cliff);
startCountDown = _start;
token = _tokenAddress;
presaleBonus = _presaleBonus;
ContractUpdated(true);
return true;
}
function returnVestingSchedule() external view returns (uint, uint, uint) {
return (duration, cliff, startCountDown);
}
// @note owner can revoke access to continue vesting of tokens
// @param _user {address} of user to revoke their right to vesting
function revoke(address _user) public onlyOwner() {
TokenHolder storage tokenHolder = tokenHolders[_user];
tokenHolder.revoked = true;
}
function vestedAmountAvailable() public view returns (uint amount, uint decimals) {
TokenHolder storage tokenHolder = tokenHolders[msg.sender];
uint tokensToRelease = vestedAmount(tokenHolder.tokensToSend);
// if (tokenHolder.releasedAmount + tokensToRelease > tokenHolder.tokensToSend)
// return (tokenHolder.tokensToSend - tokenHolder.releasedAmount, token.decimals());
// else
return (tokensToRelease - tokenHolder.releasedAmount, token.decimals());
}
// @notice Transfers vested available tokens to beneficiary
function release() public {
TokenHolder storage tokenHolder = tokenHolders[msg.sender];
// check if right to vesting is not revoked
require(!tokenHolder.revoked);
uint tokensToRelease = vestedAmount(tokenHolder.tokensToSend);
uint currentTokenToRelease = tokensToRelease - tokenHolder.releasedAmount;
tokenHolder.releasedAmount += currentTokenToRelease;
token.transfer(msg.sender, currentTokenToRelease);
Released(currentTokenToRelease, token.decimals());
}
// @notice this function will determine vested amount
// @param _totalBalance {uint} total balance of tokens assigned to this user
// @return {uint} amount of tokens available to transfer
function vestedAmount(uint _totalBalance) public view returns (uint) {
if (now < cliff) {
return 0;
} else if (now >= startCountDown.add(duration)) {
return _totalBalance;
} else {
return _totalBalance.mul(now.sub(startCountDown)) / duration;
}
}
}
// Crowdsale Smart Contract
// This smart contract collects ETH and in return sends tokens to the Backers
contract Crowdsale is Pausable, TokenVesting {
using SafeMath for uint;
address public multisigETH; // Multisig contract that will receive the ETH
address public commissionAddress; // address to deposit commissions
uint public tokensForTeam; // tokens for the team
uint public ethReceivedPresale; // Number of ETH received in presale
uint public ethReceivedMain; // Number of ETH received in main sale
uint public totalTokensSent; // Number of tokens sent to ETH contributors
uint public tokensSentMain;
uint public tokensSentPresale;
uint public tokensSentDev;
uint public startBlock; // Crowdsale start block
uint public endBlock; // Crowdsale end block
uint public maxCap; // Maximum number of token to sell
uint public minCap; // Minimum number of ETH to raise
uint public minContributionMainSale; // Minimum amount to contribute in main sale
uint public minContributionPresale; // Minimum amount to contribut in presale
uint public maxContribution;
bool public crowdsaleClosed; // Is crowdsale still on going
uint public tokenPriceWei;
uint public refundCount;
uint public totalRefunded;
uint public campaignDurationDays; // campaign duration in days
uint public firstPeriod;
uint public secondPeriod;
uint public thirdPeriod;
uint public firstBonus;
uint public secondBonus;
uint public thirdBonus;
uint public multiplier;
uint public status;
Step public currentStep; // To allow for controlled steps of the campaign
// Looping through Backer
//mapping(address => Backer) public backers; //backer list
address[] public holdersIndex; // to be able to itarate through backers when distributing the tokens
address[] public devIndex; // to be able to itarate through backers when distributing the tokens
// @notice to set and determine steps of crowdsale
enum Step {
FundingPreSale, // presale mode
FundingMainSale, // public mode
Refunding // in case campaign failed during this step contributors will be able to receive refunds
}
// @notice to verify if action is not performed out of the campaing range
modifier respectTimeFrame() {
if ((block.number < startBlock) || (block.number > endBlock))
revert();
_;
}
modifier minCapNotReached() {
if (totalTokensSent >= minCap)
revert();
_;
}
// Events
event LogReceivedETH(address indexed backer, uint amount, uint tokenAmount);
event LogStarted(uint startBlockLog, uint endBlockLog);
event LogFinalized(bool success);
event LogRefundETH(address indexed backer, uint amount);
event LogStepAdvanced();
event LogDevTokensAllocated(address indexed dev, uint amount);
event LogNonVestedTokensSent(address indexed user, uint amount);
// Crowdsale {constructor}
// @notice fired when contract is crated. Initilizes all constnat variables.
function Crowdsale(uint _decimalPoints,
address _multisigETH,
uint _toekensForTeam,
uint _minContributionPresale,
uint _minContributionMainSale,
uint _maxContribution,
uint _maxCap,
uint _minCap,
uint _tokenPriceWei,
uint _campaignDurationDays,
uint _firstPeriod,
uint _secondPeriod,
uint _thirdPeriod,
uint _firstBonus,
uint _secondBonus,
uint _thirdBonus) public {
multiplier = 10**_decimalPoints;
multisigETH = _multisigETH;
tokensForTeam = _toekensForTeam * multiplier;
minContributionPresale = _minContributionPresale;
minContributionMainSale = _minContributionMainSale;
maxContribution = _maxContribution;
maxCap = _maxCap * multiplier;
minCap = _minCap * multiplier;
tokenPriceWei = _tokenPriceWei;
campaignDurationDays = _campaignDurationDays;
firstPeriod = _firstPeriod;
secondPeriod = _secondPeriod;
thirdPeriod = _thirdPeriod;
firstBonus = _firstBonus;
secondBonus = _secondBonus;
thirdBonus = _thirdBonus;
//TODO replace this address below with correct address.
commissionAddress = 0x326B5E9b8B2ebf415F9e91b42c7911279d296ea1;
//commissionAddress = 0x853A3F142430658A32f75A0dc891b98BF4bDF5c1;
currentStep = Step.FundingPreSale;
}
// @notice to populate website with status of the sale
function returnWebsiteData() external view returns(uint,
uint, uint, uint, uint, uint, uint, uint, uint, uint, bool, bool, uint, Step) {
return (startBlock, endBlock, numberOfBackers(), ethReceivedPresale + ethReceivedMain, maxCap, minCap,
totalTokensSent, tokenPriceWei, minContributionPresale, minContributionMainSale,
paused, crowdsaleClosed, token.decimals(), currentStep);
}
// @notice this function will determine status of crowdsale
function determineStatus() external view returns (uint) {
if (crowdsaleClosed) // ICO finihsed
return 1;
if (block.number < endBlock && totalTokensSent < maxCap - 100) // ICO in progress
return 2;
if (totalTokensSent < minCap && block.number > endBlock) // ICO failed
return 3;
if (endBlock == 0) // ICO hasn't been started yet
return 4;
return 0;
}
// {fallback function}
// @notice It will call internal function which handels allocation of Ether and calculates tokens.
function () public payable {
contribute(msg.sender);
}
// @notice to allow for contribution from interface
function contributePublic() external payable {
contribute(msg.sender);
}
// @notice set the step of the campaign from presale to public sale
// contract is deployed in presale mode
// WARNING: there is no way to go back
function advanceStep() external onlyOwner() {
currentStep = Step.FundingMainSale;
LogStepAdvanced();
}
// @notice It will be called by owner to start the sale
function start() external onlyOwner() {
startBlock = block.number;
endBlock = startBlock + (4*60*24*campaignDurationDays); // assumption is that one block takes 15 sec.
crowdsaleClosed = false;
LogStarted(startBlock, endBlock);
}
// @notice This function will finalize the sale.
// It will only execute if predetermined sale time passed or all tokens are sold.
function finalize() external onlyOwner() {
require(!crowdsaleClosed);
require(block.number >= endBlock || totalTokensSent > maxCap - 1000);
// - 1000 is used to allow closing of the campaing when contribution is near
// finished as exact amount of maxCap might be not feasible e.g. you can't easily buy few tokens.
// when min contribution is 0.1 Eth.
require(totalTokensSent >= minCap);
crowdsaleClosed = true;
// transfer commission portion to the platform
commissionAddress.transfer(determineCommissions());
// transfer remaning funds to the campaign wallet
multisigETH.transfer(this.balance);
/*if (!token.transfer(owner, token.balanceOf(this)))
revert(); // transfer tokens to admin account
if (!token.burn(this, token.balanceOf(this)))
revert(); // burn all the tokens remaining in the contract */
token.unlock(); // release lock from transfering tokens.
LogFinalized(true);
}
// @notice it will allow contributors to get refund in case campaign failed
// @return {bool} true if successful
function refund() external whenNotPaused returns (bool) {
uint totalEtherReceived = ethReceivedPresale + ethReceivedMain;
require(totalEtherReceived < minCap); // ensure that campaign failed
require(this.balance > 0); // contract will hold 0 ether at the end of campaign.
// contract needs to be funded through fundContract()
TokenHolder storage backer = tokenHolders[msg.sender];
require(backer.weiReceived > 0); // ensure that user has sent contribution
require(!backer.refunded); // ensure that user hasn't been refunded yet
backer.refunded = true; // save refund status to true
refundCount++;
totalRefunded += backer.weiReceived;
if (!token.burn(msg.sender, backer.tokensToSend)) // burn tokens
revert();
msg.sender.transfer(backer.weiReceived); // send back the contribution
LogRefundETH(msg.sender, backer.weiReceived);
return true;
}
// @notice allocate tokens to dev/team/advisors
// @param _dev {address}
// @param _amount {uint} amount of tokens
function devAllocation(address _dev, uint _amount) external onlyOwner() returns (bool) {
require(_dev != address(0));
require(crowdsaleClosed);
require(totalTokensSent.add(_amount) <= token.totalSupply());
devIndex.push(_dev);
TokenHolder storage tokenHolder = tokenHolders[_dev];
tokenHolder.tokensToSend = _amount;
tokensSentDev += _amount;
totalTokensSent += _amount;
LogDevTokensAllocated(_dev, _amount); // Register event
return true;
}
// @notice Failsafe drain
function drain(uint _amount) external onlyOwner() {
owner.transfer(_amount);
}
// @notice transfer tokens which are not subject to vesting
// @param _recipient {addres}
// @param _amont {uint} amount to transfer
function transferTokens(address _recipient, uint _amount) external onlyOwner() returns (bool) {
require(_recipient != address(0));
if (!token.transfer(_recipient, _amount))
revert();
LogNonVestedTokensSent(_recipient, _amount);
}
// @notice determine amount of commissions for the platform
function determineCommissions() public view returns (uint) {
if (this.balance <= 500 ether) {
return (this.balance * 10)/100;
}else if (this.balance <= 1000 ether) {
return (this.balance * 8)/100;
}else if (this.balance < 10000 ether) {
return (this.balance * 6)/100;
}else {
return (this.balance * 6)/100;
}
}
// @notice return number of contributors
// @return {uint} number of contributors
function numberOfBackers() public view returns (uint) {
return holdersIndex.length;
}
// @notice It will be called by fallback function whenever ether is sent to it
// @param _backer {address} address of beneficiary
// @return res {bool} true if transaction was successful
function contribute(address _backer) internal whenNotPaused respectTimeFrame returns(bool res) {
//require(msg.value <= maxContribution);
if (whiteList != address(0)) // if whitelist initialized verify member whitelist status
require(whiteList.isWhiteListed(_backer)); // ensure that user is whitelisted
uint tokensToSend = calculateNoOfTokensToSend(); // calculate number of tokens
// Ensure that max cap hasn't been reached
require(totalTokensSent + tokensToSend <= maxCap);
TokenHolder storage backer = tokenHolders[_backer];
if (backer.weiReceived == 0)
holdersIndex.push(_backer);
if (Step.FundingMainSale == currentStep) { // Update the total Ether received and tokens sent during public sale
require(msg.value >= minContributionMainSale); // stop when required minimum is not met
ethReceivedMain = ethReceivedMain.add(msg.value);
tokensSentMain += tokensToSend;
}else {
require(msg.value >= minContributionPresale); // stop when required minimum is not met
ethReceivedPresale = ethReceivedPresale.add(msg.value);
tokensSentPresale += tokensToSend;
}
backer.tokensToSend += tokensToSend;
backer.weiReceived = backer.weiReceived.add(msg.value);
totalTokensSent += tokensToSend;
// tokens are not transferrd to contributors during this phase
// tokens will be transferred based on the vesting schedule, when contributor
// calls release() function of this contract
LogReceivedETH(_backer, msg.value, tokensToSend); // Register event
return true;
}
// @notice This function will return number of tokens based on time intervals in the campaign
function calculateNoOfTokensToSend() internal view returns (uint) {
uint tokenAmount = msg.value.mul(multiplier) / tokenPriceWei;
if (Step.FundingMainSale == currentStep) {
if (block.number <= startBlock + firstPeriod) {
return tokenAmount + tokenAmount.mul(firstBonus) / 100;
}else if (block.number <= startBlock + secondPeriod) {
return tokenAmount + tokenAmount.mul(secondBonus) / 100;
}else if (block.number <= startBlock + thirdPeriod) {
return tokenAmount + tokenAmount.mul(thirdBonus) / 100;
}else {
return tokenAmount;
}
}else
return tokenAmount + tokenAmount.mul(presaleBonus) / 100;
}
}
// The token
contract Token is ERC20, Ownable {
using SafeMath for uint;
// Public variables of the token
string public name;
string public symbol;
uint public decimals; // How many decimals to show.
string public version = "v0.1";
uint public totalSupply;
bool public locked;
address public crowdSaleAddress;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
// Lock transfer during the ICO
modifier onlyUnlocked() {
if (msg.sender != crowdSaleAddress && locked && msg.sender != owner)
revert();
_;
}
modifier onlyAuthorized() {
if (msg.sender != crowdSaleAddress && msg.sender != owner)
revert();
_;
}
// The Token constructor
function Token(uint _initialSupply,
string _tokenName,
uint _decimalUnits,
string _tokenSymbol,
string _version,
address _crowdSaleAddress) public {
locked = true; // Lock the transfer of tokens during the crowdsale
totalSupply = _initialSupply * (10**_decimalUnits);
name = _tokenName; // Set the name for display purposes
symbol = _tokenSymbol; // Set the symbol for display purposes
decimals = _decimalUnits; // Amount of decimals for display purposes
version = _version;
crowdSaleAddress = _crowdSaleAddress;
balances[crowdSaleAddress] = totalSupply;
}
function unlock() public onlyAuthorized {
locked = false;
}
function lock() public onlyAuthorized {
locked = true;
}
function burn(address _member, uint256 _value) public onlyAuthorized returns(bool) {
require(balances[_member] >= _value);
balances[_member] -= _value;
totalSupply -= _value;
Transfer(_member, 0x0, _value);
return true;
}
// @notice transfer tokens to given address
// @param _to {address} address or recipient
// @param _value {uint} amount to transfer
// @return {bool} true if successful
function transfer(address _to, uint _value) public onlyUnlocked returns(bool) {
require(_to != address(0));
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
// @notice transfer tokens from given address to another address
// @param _from {address} from whom tokens are transferred
// @param _to {address} to whom tokens are transferred
// @param _value {uint} amount of tokens to transfer
// @return {bool} true if successful
function transferFrom(address _from, address _to, uint256 _value) public onlyUnlocked returns(bool success) {
require(_to != address(0));
require(balances[_from] >= _value); // Check if the sender has enough
require(_value <= allowed[_from][msg.sender]); // Check if allowed is greater or equal
balances[_from] -= _value; // Subtract from the sender
balances[_to] += _value; // Add the same to the recipient
allowed[_from][msg.sender] -= _value; // adjust allowed
Transfer(_from, _to, _value);
return true;
}
// @notice to query balance of account
// @return _owner {address} address of user to query balance
function balanceOf(address _owner) public view returns(uint balance) {
return balances[_owner];
}
/**
* @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, uint _value) public returns(bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
// @notice to query of allowance of one user to the other
// @param _owner {address} of the owner of the account
// @param _spender {address} of the spender of the account
// @return remaining {uint} amount of remaining allowance
function allowance(address _owner, address _spender) public view returns(uint remaining) {
return allowed[_owner][_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
*/
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;
}
}