-
-
Save cmaliwal/31a80d36b8d873a3dca37b2b18188164 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
pragma solidity ^0.4.21; | |
contract ERC20Basic { | |
function totalSupply() public view returns (uint256); | |
function balanceOf(address who) public view returns (uint256); | |
function transfer(address to, uint256 value) public returns (bool); | |
event Transfer(address indexed from, address indexed to, uint256 value); | |
} | |
contract BasicToken is ERC20Basic { | |
using SafeMath for uint256; | |
mapping(address => uint256) balances; | |
uint256 totalSupply_; | |
function totalSupply() public view returns (uint256) { | |
return totalSupply_; | |
} | |
function transfer(address _to, uint256 _value) public returns (bool) { | |
require(_to != address(0)); | |
require(_value <= balances[msg.sender]); | |
// SafeMath.sub will throw if there is not enough balance. | |
balances[msg.sender] = balances[msg.sender].sub(_value); | |
balances[_to] = balances[_to].add(_value); | |
emit Transfer(msg.sender, _to, _value); | |
return true; | |
} | |
function balanceOf(address _owner) public view returns (uint256 balance) { | |
return balances[_owner]; | |
} | |
} | |
contract ERC20 is ERC20Basic { | |
function allowance(address owner, address spender) public view returns (uint256); | |
function transferFrom(address from, address to, uint256 value) public returns (bool); | |
function approve(address spender, uint256 value) public returns (bool); | |
event Approval(address indexed owner, address indexed spender, uint256 value); | |
} | |
contract Ownable { | |
address public owner; | |
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); | |
constructor() public { | |
owner = msg.sender; | |
} | |
modifier onlyOwner() { | |
require(msg.sender == owner); | |
_; | |
} | |
function transferOwnership(address newOwner) public onlyOwner { | |
require(newOwner != address(0)); | |
emit OwnershipTransferred(owner, newOwner); | |
owner = newOwner; | |
} | |
} | |
library SafeMath { | |
function mul(uint256 a, uint256 b) internal pure returns (uint256) { | |
if (a == 0) { | |
return 0; | |
} | |
uint256 c = a * b; | |
assert(c / a == b); | |
return c; | |
} | |
function div(uint256 a, uint256 b) internal pure returns (uint256) { | |
uint256 c = a / b; | |
return c; | |
} | |
function sub(uint256 a, uint256 b) internal pure returns (uint256) { | |
assert(b <= a); | |
return a - b; | |
} | |
function add(uint256 a, uint256 b) internal pure returns (uint256) { | |
uint256 c = a + b; | |
assert(c >= a); | |
return c; | |
} | |
} | |
contract StandardToken is ERC20, BasicToken { | |
mapping (address => mapping (address => uint256)) internal allowed; | |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { | |
require(_to != address(0)); | |
require(_value <= balances[_from]); | |
require(_value <= allowed[_from][msg.sender]); | |
balances[_from] = balances[_from].sub(_value); | |
balances[_to] = balances[_to].add(_value); | |
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); | |
emit Transfer(_from, _to, _value); | |
return true; | |
} | |
function approve(address _spender, uint256 _value) public returns (bool) { | |
allowed[msg.sender][_spender] = _value; | |
emit Approval(msg.sender, _spender, _value); | |
return true; | |
} | |
function allowance(address _owner, address _spender) public view returns (uint256) { | |
return allowed[_owner][_spender]; | |
} | |
function increaseApproval(address _spender, uint _addedValue) public returns (bool) { | |
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); | |
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); | |
return true; | |
} | |
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { | |
uint oldValue = allowed[msg.sender][_spender]; | |
if (_subtractedValue > oldValue) { | |
allowed[msg.sender][_spender] = 0; | |
} else { | |
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); | |
} | |
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); | |
return true; | |
} | |
} | |
contract DeveloperToken is StandardToken { | |
string public constant name = "DeveloperToken"; | |
string public constant symbol = "DEV"; | |
uint256 public constant decimals = 18; | |
} | |
contract DeveloperCrowdsale is Ownable { | |
using SafeMath for uint256; | |
// ============= Token Distribution ================ | |
uint256 public maxTokens = 100000000 *(10 ** 18); | |
uint256 public tokensForEcosystem = 80000000 *(10 ** 18); | |
uint256 public tokensForBounty = 4000000 *(10 ** 18); | |
uint256 public totalTokensForSale = 15000000 *(10 ** 18); | |
uint256 public tokenForAirdrop = 1000000 *(10 ** 18); | |
ERC20 public token; | |
address public wallet; | |
uint256 public rate; | |
uint256 public weiRaised; | |
uint256 public cap; | |
uint256 public goal; | |
// start and end timestamps where investments are allowed (both inclusive) | |
uint256 public startTime; | |
uint256 public endTime; | |
bool public mintingFinished = false; | |
mapping(address => uint256) balances; | |
event Mint(address indexed to, uint256 amount); | |
event MintFinished(); | |
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); | |
event NewRate(uint256 rate); | |
constructor() public { | |
rate = 1000; | |
wallet = msg.sender; | |
token = new DeveloperToken(); | |
startTime = 1527186660000; // new Date('05/25/2018 00:01').getTime(); | |
endTime = 1529951340000; // new Date('06/25/2018 23:59').getTime(); | |
cap = 42500 *(10 ** 18); | |
goal = 7500 *(10 ** 18); | |
} | |
function () external payable { | |
uint256 tokensThatWillBeMintedAfterPurchase = msg.value.mul(rate); | |
require(token.totalSupply() + tokensThatWillBeMintedAfterPurchase < totalTokensForSale); | |
buyTokens(msg.sender); | |
} | |
// ====================== Crowdsale Price Management ================= | |
function setCrowdsalePrice() public onlyOwner { | |
if (weiRaised <= 2500000 *(10 ** 18)) { | |
setCurrentRate(1000); | |
} else if (weiRaised <= 5000000 *(10 ** 18)) { | |
setCurrentRate(500); | |
} else if (weiRaised <= 10000000 *(10 ** 18)) { | |
setCurrentRate(333); | |
} else if (weiRaised <= 15000000 *(10 ** 18)) { | |
setCurrentRate(250); | |
} | |
} | |
// Change the current rate | |
function setCurrentRate(uint256 _rate) private onlyOwner { | |
rate = _rate; | |
emit NewRate(rate); | |
} | |
function buyTokens(address _beneficiary) public payable { | |
require(validPurchase()); | |
uint256 weiAmount = msg.value; | |
// calculate token amount to be created | |
uint256 tokens = _getTokenAmount(weiAmount); | |
// update state | |
weiRaised = weiRaised.add(weiAmount); | |
_deliverTokens(_beneficiary, tokens); | |
emit TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens); | |
_forwardFunds(); | |
} | |
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal { | |
token.transfer(_beneficiary, _tokenAmount); | |
} | |
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { | |
return _weiAmount.mul(rate); | |
} | |
function _forwardFunds() internal { | |
token.totalSupply() + msg.value.mul(rate); | |
wallet.transfer(msg.value); | |
} | |
// Finish: Mint Extra Tokens as needed before finalizing the Crowdsale. | |
function finish(address _airdrop, address _ecosystemFund, address _bountyFund) public onlyOwner { | |
require(!mintingFinished); | |
require(_airdrop != address(0)); | |
require(_ecosystemFund != address(0)); | |
require(_bountyFund != address(0)); | |
require(hasEnded()); | |
uint256 alreadyMinted = token.totalSupply(); | |
require(alreadyMinted < maxTokens); | |
uint256 unsoldTokens = totalTokensForSale - alreadyMinted; | |
if (unsoldTokens > 0) { | |
tokensForEcosystem = tokensForEcosystem + unsoldTokens; | |
} | |
token.totalSupply().add(tokensForEcosystem); | |
token.totalSupply().add(tokensForBounty); | |
token.totalSupply().add(tokenForAirdrop); | |
balances[_airdrop].add(tokenForAirdrop); | |
balances[_ecosystemFund].add(tokensForEcosystem); | |
balances[_bountyFund].add(tokensForBounty); | |
mintingFinished = true ; | |
} | |
// @return true if the transaction can buy tokens | |
function validPurchase() internal view returns (bool) { | |
bool withinCap = weiRaised.add(msg.value) <= cap; | |
bool withinPeriod = now >= startTime && now <= endTime; | |
bool nonZeroPurchase = msg.value != 0; | |
return withinPeriod && nonZeroPurchase && withinCap; | |
} | |
// @return true if crowdsale event has ended | |
function hasEnded() public view returns (bool) { | |
bool capReached = weiRaised >= cap; | |
return now > endTime || capReached; | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment