Created
March 10, 2018 17:44
-
-
Save artiya4u/42c38b327951cfe2e5eb386deed6b8ba 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.18; | |
// File: zeppelin-solidity/contracts/math/SafeMath.sol | |
/** | |
* @title SafeMath | |
* @dev Math operations with safety checks that throw on error | |
*/ | |
library SafeMath { | |
/** | |
* @dev Multiplies two numbers, throws on overflow. | |
*/ | |
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; | |
} | |
/** | |
* @dev Integer division of two numbers, truncating the quotient. | |
*/ | |
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; | |
} | |
/** | |
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend). | |
*/ | |
function sub(uint256 a, uint256 b) internal pure returns (uint256) { | |
assert(b <= a); | |
return a - b; | |
} | |
/** | |
* @dev Adds two numbers, throws on overflow. | |
*/ | |
function add(uint256 a, uint256 b) internal pure returns (uint256) { | |
uint256 c = a + b; | |
assert(c >= a); | |
return c; | |
} | |
} | |
// File: zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol | |
/** | |
* @title ERC20Basic | |
* @dev Simpler version of ERC20 interface | |
* @dev see https://github.com/ethereum/EIPs/issues/179 | |
*/ | |
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); | |
} | |
// File: zeppelin-solidity/contracts/token/ERC20/ERC20.sol | |
/** | |
* @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); | |
} | |
// File: zeppelin-solidity/contracts/crowdsale/Crowdsale.sol | |
/** | |
* @title Crowdsale | |
* @dev Crowdsale is a base contract for managing a token crowdsale, | |
* allowing investors to purchase tokens with ether. This contract implements | |
* such functionality in its most fundamental form and can be extended to provide additional | |
* functionality and/or custom behavior. | |
* The external interface represents the basic interface for purchasing tokens, and conform | |
* the base architecture for crowdsales. They are *not* intended to be modified / overriden. | |
* The internal interface conforms the extensible and modifiable surface of crowdsales. Override | |
* the methods to add functionality. Consider using 'super' where appropiate to concatenate | |
* behavior. | |
*/ | |
contract Crowdsale { | |
using SafeMath for uint256; | |
// The token being sold | |
ERC20 public token; | |
// Address where funds are collected | |
address public wallet; | |
// How many token units a buyer gets per wei | |
uint256 public rate; | |
// Amount of wei raised | |
uint256 public weiRaised; | |
/** | |
* Event for token purchase logging | |
* @param purchaser who paid for the tokens | |
* @param beneficiary who got the tokens | |
* @param value weis paid for purchase | |
* @param amount amount of tokens purchased | |
*/ | |
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); | |
/** | |
* @param _rate Number of token units a buyer gets per wei | |
* @param _wallet Address where collected funds will be forwarded to | |
* @param _token Address of the token being sold | |
*/ | |
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public { | |
require(_rate > 0); | |
require(_wallet != address(0)); | |
require(_token != address(0)); | |
rate = _rate; | |
wallet = _wallet; | |
token = _token; | |
} | |
// ----------------------------------------- | |
// Crowdsale external interface | |
// ----------------------------------------- | |
/** | |
* @dev fallback function ***DO NOT OVERRIDE*** | |
*/ | |
function () external payable { | |
buyTokens(msg.sender); | |
} | |
/** | |
* @dev low level token purchase ***DO NOT OVERRIDE*** | |
* @param _beneficiary Address performing the token purchase | |
*/ | |
function buyTokens(address _beneficiary) public payable { | |
uint256 weiAmount = msg.value; | |
_preValidatePurchase(_beneficiary, weiAmount); | |
// calculate token amount to be created | |
uint256 tokens = _getTokenAmount(weiAmount); | |
// update state | |
weiRaised = weiRaised.add(weiAmount); | |
_processPurchase(_beneficiary, tokens); | |
TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens); | |
_updatePurchasingState(_beneficiary, weiAmount); | |
_forwardFunds(); | |
_postValidatePurchase(_beneficiary, weiAmount); | |
} | |
// ----------------------------------------- | |
// Internal interface (extensible) | |
// ----------------------------------------- | |
/** | |
* @dev Validation of an incoming purchase. Use require statemens to revert state when conditions are not met. Use super to concatenate validations. | |
* @param _beneficiary Address performing the token purchase | |
* @param _weiAmount Value in wei involved in the purchase | |
*/ | |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal { | |
require(_beneficiary != address(0)); | |
require(_weiAmount != 0); | |
} | |
/** | |
* @dev Validation of an executed purchase. Observe state and use revert statements to undo rollback when valid conditions are not met. | |
* @param _beneficiary Address performing the token purchase | |
* @param _weiAmount Value in wei involved in the purchase | |
*/ | |
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal { | |
// optional override | |
} | |
/** | |
* @dev Source of tokens. Override this method to modify the way in which the crowdsale ultimately gets and sends its tokens. | |
* @param _beneficiary Address performing the token purchase | |
* @param _tokenAmount Number of tokens to be emitted | |
*/ | |
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal { | |
token.transfer(_beneficiary, _tokenAmount); | |
} | |
/** | |
* @dev Executed when a purchase has been validated and is ready to be executed. Not necessarily emits/sends tokens. | |
* @param _beneficiary Address receiving the tokens | |
* @param _tokenAmount Number of tokens to be purchased | |
*/ | |
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal { | |
_deliverTokens(_beneficiary, _tokenAmount); | |
} | |
/** | |
* @dev Override for extensions that require an internal state to check for validity (current user contributions, etc.) | |
* @param _beneficiary Address receiving the tokens | |
* @param _weiAmount Value in wei involved in the purchase | |
*/ | |
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal { | |
// optional override | |
} | |
/** | |
* @dev Override to extend the way in which ether is converted to tokens. | |
* @param _weiAmount Value in wei to be converted into tokens | |
* @return Number of tokens that can be purchased with the specified _weiAmount | |
*/ | |
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { | |
return _weiAmount.mul(rate); | |
} | |
/** | |
* @dev Determines how ETH is stored/forwarded on purchases. | |
*/ | |
function _forwardFunds() internal { | |
wallet.transfer(msg.value); | |
} | |
} | |
// File: zeppelin-solidity/contracts/crowdsale/emission/AllowanceCrowdsale.sol | |
/** | |
* @title AllowanceCrowdsale | |
* @dev Extension of Crowdsale where tokens are held by a wallet, which approves an allowance to the crowdsale. | |
*/ | |
contract AllowanceCrowdsale is Crowdsale { | |
using SafeMath for uint256; | |
address public tokenWallet; | |
/** | |
* @dev Constructor, takes token wallet address. | |
* @param _tokenWallet Address holding the tokens, which has approved allowance to the crowdsale | |
*/ | |
function AllowanceCrowdsale(address _tokenWallet) public { | |
require(_tokenWallet != address(0)); | |
tokenWallet = _tokenWallet; | |
} | |
/** | |
* @dev Checks the amount of tokens left in the allowance. | |
* @return Amount of tokens left in the allowance | |
*/ | |
function remainingTokens() public view returns (uint256) { | |
return token.allowance(tokenWallet, this); | |
} | |
/** | |
* @dev Overrides parent behavior by transferring tokens from wallet. | |
* @param _beneficiary Token purchaser | |
* @param _tokenAmount Amount of tokens purchased | |
*/ | |
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal { | |
token.transferFrom(tokenWallet, _beneficiary, _tokenAmount); | |
} | |
} | |
// File: zeppelin-solidity/contracts/crowdsale/validation/CappedCrowdsale.sol | |
/** | |
* @title CappedCrowdsale | |
* @dev Crowdsale with a limit for total contributions. | |
*/ | |
contract CappedCrowdsale is Crowdsale { | |
using SafeMath for uint256; | |
uint256 public cap; | |
/** | |
* @dev Constructor, takes maximum amount of wei accepted in the crowdsale. | |
* @param _cap Max amount of wei to be contributed | |
*/ | |
function CappedCrowdsale(uint256 _cap) public { | |
require(_cap > 0); | |
cap = _cap; | |
} | |
/** | |
* @dev Checks whether the cap has been reached. | |
* @return Whether the cap was reached | |
*/ | |
function capReached() public view returns (bool) { | |
return weiRaised >= cap; | |
} | |
/** | |
* @dev Extend parent behavior requiring purchase to respect the funding cap. | |
* @param _beneficiary Token purchaser | |
* @param _weiAmount Amount of wei contributed | |
*/ | |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal { | |
super._preValidatePurchase(_beneficiary, _weiAmount); | |
require(weiRaised.add(_weiAmount) <= cap); | |
} | |
} | |
// File: zeppelin-solidity/contracts/ownership/Ownable.sol | |
/** | |
* @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) public onlyOwner { | |
require(newOwner != address(0)); | |
OwnershipTransferred(owner, newOwner); | |
owner = newOwner; | |
} | |
} | |
// File: zeppelin-solidity/contracts/crowdsale/validation/IndividuallyCappedCrowdsale.sol | |
/** | |
* @title IndividuallyCappedCrowdsale | |
* @dev Crowdsale with per-user caps. | |
*/ | |
contract IndividuallyCappedCrowdsale is Crowdsale, Ownable { | |
using SafeMath for uint256; | |
mapping(address => uint256) public contributions; | |
mapping(address => uint256) public caps; | |
/** | |
* @dev Sets a specific user's maximum contribution. | |
* @param _beneficiary Address to be capped | |
* @param _cap Wei limit for individual contribution | |
*/ | |
function setUserCap(address _beneficiary, uint256 _cap) external onlyOwner { | |
caps[_beneficiary] = _cap; | |
} | |
/** | |
* @dev Sets a group of users' maximum contribution. | |
* @param _beneficiaries List of addresses to be capped | |
* @param _cap Wei limit for individual contribution | |
*/ | |
function setGroupCap(address[] _beneficiaries, uint256 _cap) external onlyOwner { | |
for (uint256 i = 0; i < _beneficiaries.length; i++) { | |
caps[_beneficiaries[i]] = _cap; | |
} | |
} | |
/** | |
* @dev Returns the cap of a specific user. | |
* @param _beneficiary Address whose cap is to be checked | |
* @return Current cap for individual user | |
*/ | |
function getUserCap(address _beneficiary) public view returns (uint256) { | |
return caps[_beneficiary]; | |
} | |
/** | |
* @dev Returns the amount contributed so far by a sepecific user. | |
* @param _beneficiary Address of contributor | |
* @return User contribution so far | |
*/ | |
function getUserContribution(address _beneficiary) public view returns (uint256) { | |
return contributions[_beneficiary]; | |
} | |
/** | |
* @dev Extend parent behavior requiring purchase to respect the user's funding cap. | |
* @param _beneficiary Token purchaser | |
* @param _weiAmount Amount of wei contributed | |
*/ | |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal { | |
super._preValidatePurchase(_beneficiary, _weiAmount); | |
require(contributions[_beneficiary].add(_weiAmount) <= caps[_beneficiary]); | |
} | |
/** | |
* @dev Extend parent behavior to update user contributions | |
* @param _beneficiary Token purchaser | |
* @param _weiAmount Amount of wei contributed | |
*/ | |
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal { | |
super._updatePurchasingState(_beneficiary, _weiAmount); | |
contributions[_beneficiary] = contributions[_beneficiary].add(_weiAmount); | |
} | |
} | |
// File: zeppelin-solidity/contracts/crowdsale/validation/TimedCrowdsale.sol | |
/** | |
* @title TimedCrowdsale | |
* @dev Crowdsale accepting contributions only within a time frame. | |
*/ | |
contract TimedCrowdsale is Crowdsale { | |
using SafeMath for uint256; | |
uint256 public openingTime; | |
uint256 public closingTime; | |
/** | |
* @dev Reverts if not in crowdsale time range. | |
*/ | |
modifier onlyWhileOpen { | |
require(now >= openingTime && now <= closingTime); | |
_; | |
} | |
/** | |
* @dev Constructor, takes crowdsale opening and closing times. | |
* @param _openingTime Crowdsale opening time | |
* @param _closingTime Crowdsale closing time | |
*/ | |
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public { | |
require(_openingTime >= now); | |
require(_closingTime >= _openingTime); | |
openingTime = _openingTime; | |
closingTime = _closingTime; | |
} | |
/** | |
* @dev Checks whether the period in which the crowdsale is open has already elapsed. | |
* @return Whether crowdsale period has elapsed | |
*/ | |
function hasClosed() public view returns (bool) { | |
return now > closingTime; | |
} | |
/** | |
* @dev Extend parent behavior requiring to be within contributing period | |
* @param _beneficiary Token purchaser | |
* @param _weiAmount Amount of wei contributed | |
*/ | |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal onlyWhileOpen { | |
super._preValidatePurchase(_beneficiary, _weiAmount); | |
} | |
} | |
// File: contracts/CarboneumCrowdsale.sol | |
/** | |
* @title CarboneumCrowdsale | |
* @dev This is Carboneum fully fledged crowdsale. | |
* CappedCrowdsale - sets a max boundary for raised funds. | |
* AllowanceCrowdsale - token held by a wallet. | |
* IndividuallyCappedCrowdsale - Crowdsale with per-user caps. | |
* TimedCrowdsale - Crowdsale accepting contributions only within a time frame. | |
*/ | |
contract CarboneumCrowdsale is CappedCrowdsale, AllowanceCrowdsale, IndividuallyCappedCrowdsale, TimedCrowdsale { | |
uint256 public pre_sale_end; | |
function CarboneumCrowdsale( | |
uint256 _openingTime, | |
uint256 _closingTime, | |
uint256 _rate, | |
address _tokenWallet, | |
address _fundWallet, | |
uint256 _cap, | |
ERC20 _token, | |
uint256 _preSaleEnd) public | |
AllowanceCrowdsale(_tokenWallet) | |
Crowdsale(_rate, _fundWallet, _token) | |
CappedCrowdsale(_cap) | |
TimedCrowdsale(_openingTime, _closingTime) | |
{ | |
require(_preSaleEnd < _closingTime); | |
pre_sale_end = _preSaleEnd; | |
} | |
/** | |
* @dev Add bonus to pre-sale period. | |
* @param _weiAmount Value in wei to be converted into tokens | |
* @return Number of tokens that can be purchased with the specified _weiAmount | |
*/ | |
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { | |
uint256 newRate = rate; | |
if (now < pre_sale_end) { // solium-disable-line security/no-block-members | |
// Bonus 8% | |
newRate += rate * 8 / 100; | |
} | |
return _weiAmount.mul(newRate); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment