1. pragma solidity ^0.5.0;
  3. /**
  4. * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
  5. * the optional functions; to access them see {ERC20Detailed}.
  6. */
  7. interface IERC20 {
  8. /**
  9. * @dev Returns the amount of tokens in existence.
  10. */
  11. function totalSupply() external view returns (uint256);
  13. /**
  14. * @dev Returns the amount of tokens owned by `account`.
  15. */
  16. function balanceOf(address account) external view returns (uint256);
  18. /**
  19. * @dev Moves `amount` tokens from the caller's account to `recipient`.
  20. *
  21. * Returns a boolean value indicating whether the operation succeeded.
  22. *
  23. * Emits a {Transfer} event.
  24. */
  25. function transfer(address recipient, uint256 amount) external returns (bool);
  27. /**
  28. * @dev Returns the remaining number of tokens that `spender` will be
  29. * allowed to spend on behalf of `owner` through {transferFrom}. This is
  30. * zero by default.
  31. *
  32. * This value changes when {approve} or {transferFrom} are called.
  33. */
  34. function allowance(address owner, address spender) external view returns (uint256);
  36. /**
  37. * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
  38. *
  39. * Returns a boolean value indicating whether the operation succeeded.
  40. *
  41. * IMPORTANT: Beware that changing an allowance with this method brings the risk
  42. * that someone may use both the old and the new allowance by unfortunate
  43. * transaction ordering. One possible solution to mitigate this race
  44. * condition is to first reduce the spender's allowance to 0 and set the
  45. * desired value afterwards:
  46. * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
  47. *
  48. * Emits an {Approval} event.
  49. */
  50. function approve(address spender, uint256 amount) external returns (bool);
  52. /**
  53. * @dev Moves `amount` tokens from `sender` to `recipient` using the
  54. * allowance mechanism. `amount` is then deducted from the caller's
  55. * allowance.
  56. *
  57. * Returns a boolean value indicating whether the operation succeeded.
  58. *
  59. * Emits a {Transfer} event.
  60. */
  61. function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
  63. /**
  64. * @dev Emitted when `value` tokens are moved from one account (`from`) to
  65. * another (`to`).
  66. *
  67. * Note that `value` may be zero.
  68. */
  69. event Transfer(address indexed from, address indexed to, uint256 value);
  71. /**
  72. * @dev Emitted when the allowance of a `spender` for an `owner` is set by
  73. * a call to {approve}. `value` is the new allowance.
  74. */
  75. event Approval(address indexed owner, address indexed spender, uint256 value);
  76. }
  78. pragma solidity ^0.5.0;
  80. /**
  81. * @dev Contract module that helps prevent reentrant calls to a function.
  82. *
  83. * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
  84. * available, which can be applied to functions to make sure there are no nested
  85. * (reentrant) calls to them.
  86. *
  87. * Note that because there is a single `nonReentrant` guard, functions marked as
  88. * `nonReentrant` may not call one another. This can be worked around by making
  89. * those functions `private`, and then adding `external` `nonReentrant` entry
  90. * points to them.
  91. *
  92. * _Since v2.5.0:_ this module is now much more gas efficient, given net gas
  93. * metering changes introduced in the Istanbul hardfork.
  94. */
  95. contract ReentrancyGuard {
  96. bool private _notEntered;
  98. constructor () internal {
  99. // Storing an initial non-zero value makes deployment a bit more
  100. // expensive, but in exchange the refund on every call to nonReentrant
  101. // will be lower in amount. Since refunds are capped to a percetange of
  102. // the total transaction's gas, it is best to keep them low in cases
  103. // like this one, to increase the likelihood of the full refund coming
  104. // into effect.
  105. _notEntered = true;
  106. }
  108. /**
  109. * @dev Prevents a contract from calling itself, directly or indirectly.
  110. * Calling a `nonReentrant` function from another `nonReentrant`
  111. * function is not supported. It is possible to prevent this from happening
  112. * by making the `nonReentrant` function external, and make it call a
  113. * `private` function that does the actual work.
  114. */
  115. modifier nonReentrant() {
  116. // On the first call to nonReentrant, _notEntered will be true
  117. require(_notEntered, "ReentrancyGuard: reentrant call");
  119. // Any calls to nonReentrant after this point will fail
  120. _notEntered = false;
  122. _;
  124. // By storing the original value once again, a refund is triggered (see
  125. // https://eips.ethereum.org/EIPS/eip-2200)
  126. _notEntered = true;
  127. }
  128. }
  131. pragma solidity ^0.5.0;
  133. /*
  134. * @dev Provides information about the current execution context, including the
  135. * sender of the transaction and its data. While these are generally available
  136. * via msg.sender and msg.data, they should not be accessed in such a direct
  137. * manner, since when dealing with GSN meta-transactions the account sending and
  138. * paying for execution may not be the actual sender (as far as an application
  139. * is concerned).
  140. *
  141. * This contract is only required for intermediate, library-like contracts.
  142. */
  143. contract Context {
  144. // Empty internal constructor, to prevent people from mistakenly deploying
  145. // an instance of this contract, which should be used via inheritance.
  146. constructor () internal { }
  147. // solhint-disable-previous-line no-empty-blocks
  149. function _msgSender() internal view returns (address payable) {
  150. return msg.sender;
  151. }
  153. function _msgData() internal view returns (bytes memory) {
  154. this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
  155. return msg.data;
  156. }
  157. }
  159. pragma solidity ^0.5.0;
  161. /**
  162. * @dev Wrappers over Solidity's arithmetic operations with added overflow
  163. * checks.
  164. *
  165. * Arithmetic operations in Solidity wrap on overflow. This can easily result
  166. * in bugs, because programmers usually assume that an overflow raises an
  167. * error, which is the standard behavior in high level programming languages.
  168. * `SafeMath` restores this intuition by reverting the transaction when an
  169. * operation overflows.
  170. *
  171. * Using this library instead of the unchecked operations eliminates an entire
  172. * class of bugs, so it's recommended to use it always.
  173. */
  174. library SafeMath {
  175. /**
  176. * @dev Returns the addition of two unsigned integers, reverting on
  177. * overflow.
  178. *
  179. * Counterpart to Solidity's `+` operator.
  180. *
  181. * Requirements:
  182. * - Addition cannot overflow.
  183. */
  184. function add(uint256 a, uint256 b) internal pure returns (uint256) {
  185. uint256 c = a + b;
  186. require(c >= a, "SafeMath: addition overflow");
  188. return c;
  189. }
  191. /**
  192. * @dev Returns the subtraction of two unsigned integers, reverting on
  193. * overflow (when the result is negative).
  194. *
  195. * Counterpart to Solidity's `-` operator.
  196. *
  197. * Requirements:
  198. * - Subtraction cannot overflow.
  199. */
  200. function sub(uint256 a, uint256 b) internal pure returns (uint256) {
  201. return sub(a, b, "SafeMath: subtraction overflow");
  202. }
  204. /**
  205. * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
  206. * overflow (when the result is negative).
  207. *
  208. * Counterpart to Solidity's `-` operator.
  209. *
  210. * Requirements:
  211. * - Subtraction cannot overflow.
  212. *
  213. * _Available since v2.4.0._
  214. */
  215. function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
  216. require(b <= a, errorMessage);
  217. uint256 c = a - b;
  219. return c;
  220. }
  222. /**
  223. * @dev Returns the multiplication of two unsigned integers, reverting on
  224. * overflow.
  225. *
  226. * Counterpart to Solidity's `*` operator.
  227. *
  228. * Requirements:
  229. * - Multiplication cannot overflow.
  230. */
  231. function mul(uint256 a, uint256 b) internal pure returns (uint256) {
  232. // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
  233. // benefit is lost if 'b' is also tested.
  234. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
  235. if (a == 0) {
  236. return 0;
  237. }
  239. uint256 c = a * b;
  240. require(c / a == b, "SafeMath: multiplication overflow");
  242. return c;
  243. }
  245. /**
  246. * @dev Returns the integer division of two unsigned integers. Reverts on
  247. * division by zero. The result is rounded towards zero.
  248. *
  249. * Counterpart to Solidity's `/` operator. Note: this function uses a
  250. * `revert` opcode (which leaves remaining gas untouched) while Solidity
  251. * uses an invalid opcode to revert (consuming all remaining gas).
  252. *
  253. * Requirements:
  254. * - The divisor cannot be zero.
  255. */
  256. function div(uint256 a, uint256 b) internal pure returns (uint256) {
  257. return div(a, b, "SafeMath: division by zero");
  258. }
  260. /**
  261. * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
  262. * division by zero. The result is rounded towards zero.
  263. *
  264. * Counterpart to Solidity's `/` operator. Note: this function uses a
  265. * `revert` opcode (which leaves remaining gas untouched) while Solidity
  266. * uses an invalid opcode to revert (consuming all remaining gas).
  267. *
  268. * Requirements:
  269. * - The divisor cannot be zero.
  270. *
  271. * _Available since v2.4.0._
  272. */
  273. function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
  274. // Solidity only automatically asserts when dividing by 0
  275. require(b > 0, errorMessage);
  276. uint256 c = a / b;
  277. // assert(a == b * c + a % b); // There is no case in which this doesn't hold
  279. return c;
  280. }
  282. /**
  283. * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
  284. * Reverts when dividing by zero.
  285. *
  286. * Counterpart to Solidity's `%` operator. This function uses a `revert`
  287. * opcode (which leaves remaining gas untouched) while Solidity uses an
  288. * invalid opcode to revert (consuming all remaining gas).
  289. *
  290. * Requirements:
  291. * - The divisor cannot be zero.
  292. */
  293. function mod(uint256 a, uint256 b) internal pure returns (uint256) {
  294. return mod(a, b, "SafeMath: modulo by zero");
  295. }
  297. /**
  298. * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
  299. * Reverts with custom message when dividing by zero.
  300. *
  301. * Counterpart to Solidity's `%` operator. This function uses a `revert`
  302. * opcode (which leaves remaining gas untouched) while Solidity uses an
  303. * invalid opcode to revert (consuming all remaining gas).
  304. *
  305. * Requirements:
  306. * - The divisor cannot be zero.
  307. *
  308. * _Available since v2.4.0._
  309. */
  310. function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
  311. require(b != 0, errorMessage);
  312. return a % b;
  313. }
  314. }
  316. pragma solidity ^0.5.0;
  319. /**
  320. * @title SafeERC20
  321. * @dev Wrappers around ERC20 operations that throw on failure (when the token
  322. * contract returns false). Tokens that return no value (and instead revert or
  323. * throw on failure) are also supported, non-reverting calls are assumed to be
  324. * successful.
  325. * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
  326. * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
  327. */
  328. library SafeERC20 {
  329. using SafeMath for uint256;
  330. using Address for address;
  332. function safeTransfer(IERC20 token, address to, uint256 value) internal {
  333. callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
  334. }
  336. function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
  337. callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
  338. }
  340. function safeApprove(IERC20 token, address spender, uint256 value) internal {
  341. // safeApprove should only be called when setting an initial allowance,
  342. // or when resetting it to zero. To increase and decrease it, use
  343. // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
  344. // solhint-disable-next-line max-line-length
  345. require((value == 0) || (token.allowance(address(this), spender) == 0),
  346. "SafeERC20: approve from non-zero to non-zero allowance"
  347. );
  348. callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
  349. }
  351. function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
  352. uint256 newAllowance = token.allowance(address(this), spender).add(value);
  353. callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
  354. }
  356. function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
  357. uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
  358. callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
  359. }
  361. /**
  362. * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
  363. * on the return value: the return value is optional (but if data is returned, it must not be false).
  364. * @param token The token targeted by the call.
  365. * @param data The call data (encoded using abi.encode or one of its variants).
  366. */
  367. function callOptionalReturn(IERC20 token, bytes memory data) private {
  368. // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
  369. // we're implementing it ourselves.
  371. // A Solidity high level call has three parts:
  372. // 1. The target address is checked to verify it contains contract code
  373. // 2. The call itself is made, and success asserted
  374. // 3. The return value is decoded, which in turn checks the size of the returned data.
  375. // solhint-disable-next-line max-line-length
  376. require(address(token).isContract(), "SafeERC20: call to non-contract");
  378. // solhint-disable-next-line avoid-low-level-calls
  379. (bool success, bytes memory returndata) = address(token).call(data);
  380. require(success, "SafeERC20: low-level call failed");
  382. if (returndata.length > 0) { // Return data is optional
  383. // solhint-disable-next-line max-line-length
  384. require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
  385. }
  386. }
  387. }
  389. pragma solidity ^0.5.0;
  391. /**
  392. * @dev Standard math utilities missing in the Solidity language.
  393. */
  394. library Math {
  395. /**
  396. * @dev Returns the largest of two numbers.
  397. */
  398. function max(uint256 a, uint256 b) internal pure returns (uint256) {
  399. return a >= b ? a : b;
  400. }
  402. /**
  403. * @dev Returns the smallest of two numbers.
  404. */
  405. function min(uint256 a, uint256 b) internal pure returns (uint256) {
  406. return a < b ? a : b;
  407. }
  409. /**
  410. * @dev Returns the average of two numbers. The result is rounded towards
  411. * zero.
  412. */
  413. function average(uint256 a, uint256 b) internal pure returns (uint256) {
  414. // (a + b) / 2 can overflow, so we distribute
  415. return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
  416. }
  417. }
  419. pragma solidity ^0.5.0;
  421. /**
  422. * @title Crowdsale
  423. * @dev Crowdsale is a base contract for managing a token crowdsale,
  424. * allowing investors to purchase tokens with ether. This contract implements
  425. * such functionality in its most fundamental form and can be extended to provide additional
  426. * functionality and/or custom behavior.
  427. * The external interface represents the basic interface for purchasing tokens, and conforms
  428. * the base architecture for crowdsales. It is *not* intended to be modified / overridden.
  429. * The internal interface conforms the extensible and modifiable surface of crowdsales. Override
  430. * the methods to add functionality. Consider using 'super' where appropriate to concatenate
  431. * behavior.
  432. */
  433. contract Crowdsale is Context, ReentrancyGuard {
  434. using SafeMath for uint256;
  435. using SafeERC20 for IERC20;
  437. // The token being sold
  438. IERC20 private _token;
  440. // Address where funds are collected
  441. address payable private _wallet;
  443. // How many token units a buyer gets per wei.
  444. // The rate is the conversion between wei and the smallest and indivisible token unit.
  445. // So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
  446. // 1 wei will give you 1 unit, or 0.001 TOK.
  447. uint256 private _rate;
  449. // Amount of wei raised
  450. uint256 private _weiRaised;
  452. /**
  453. * Event for token purchase logging
  454. * @param purchaser who paid for the tokens
  455. * @param beneficiary who got the tokens
  456. * @param value weis paid for purchase
  457. * @param amount amount of tokens purchased
  458. */
  459. event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
  461. /**
  462. * @param rate Number of token units a buyer gets per wei
  463. * @dev The rate is the conversion between wei and the smallest and indivisible
  464. * token unit. So, if you are using a rate of 1 with a ERC20Detailed token
  465. * with 3 decimals called TOK, 1 wei will give you 1 unit, or 0.001 TOK.
  466. * @param wallet Address where collected funds will be forwarded to
  467. * @param token Address of the token being sold
  468. */
  469. constructor (uint256 rate, address payable wallet, IERC20 token) public {
  470. require(rate > 0, "Crowdsale: rate is 0");
  471. require(wallet != address(0), "Crowdsale: wallet is the zero address");
  472. require(address(token) != address(0), "Crowdsale: token is the zero address");
  474. _rate = rate;
  475. _wallet = wallet;
  476. _token = token;
  477. }
  479. /**
  480. * @dev fallback function ***DO NOT OVERRIDE***
  481. * Note that other contracts will transfer funds with a base gas stipend
  482. * of 2300, which is not enough to call buyTokens. Consider calling
  483. * buyTokens directly when purchasing tokens from a contract.
  484. */
  485. function () external payable {
  486. buyTokens(_msgSender());
  487. }
  489. /**
  490. * @return the token being sold.
  491. */
  492. function token() public view returns (IERC20) {
  493. return _token;
  494. }
  496. /**
  497. * @return the address where funds are collected.
  498. */
  499. function wallet() public view returns (address payable) {
  500. return _wallet;
  501. }
  503. /**
  504. * @return the number of token units a buyer gets per wei.
  505. */
  506. function rate() public view returns (uint256) {
  507. return _rate;
  508. }
  510. /**
  511. * @return the amount of wei raised.
  512. */
  513. function weiRaised() public view returns (uint256) {
  514. return _weiRaised;
  515. }
  517. /**
  518. * @dev low level token purchase ***DO NOT OVERRIDE***
  519. * This function has a non-reentrancy guard, so it shouldn't be called by
  520. * another `nonReentrant` function.
  521. * @param beneficiary Recipient of the token purchase
  522. */
  523. function buyTokens(address beneficiary) public nonReentrant payable {
  524. uint256 weiAmount = msg.value;
  525. _preValidatePurchase(beneficiary, weiAmount);
  527. // calculate token amount to be created
  528. uint256 tokens = _getTokenAmount(weiAmount);
  530. // update state
  531. _weiRaised = _weiRaised.add(weiAmount);
  533. _processPurchase(beneficiary, tokens);
  534. emit TokensPurchased(_msgSender(), beneficiary, weiAmount, tokens);
  536. _updatePurchasingState(beneficiary, weiAmount);
  538. _forwardFunds();
  539. _postValidatePurchase(beneficiary, weiAmount);
  540. }
  542. /**
  543. * @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met.
  544. * Use `super` in contracts that inherit from Crowdsale to extend their validations.
  545. * Example from CappedCrowdsale.sol's _preValidatePurchase method:
  546. * super._preValidatePurchase(beneficiary, weiAmount);
  547. * require(weiRaised().add(weiAmount) <= cap);
  548. * @param beneficiary Address performing the token purchase
  549. * @param weiAmount Value in wei involved in the purchase
  550. */
  551. function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
  552. require(beneficiary != address(0), "Crowdsale: beneficiary is the zero address");
  553. require(weiAmount != 0, "Crowdsale: weiAmount is 0");
  554. this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
  555. }
  557. /**
  558. * @dev Validation of an executed purchase. Observe state and use revert statements to undo rollback when valid
  559. * conditions are not met.
  560. * @param beneficiary Address performing the token purchase
  561. * @param weiAmount Value in wei involved in the purchase
  562. */
  563. function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
  564. // solhint-disable-previous-line no-empty-blocks
  565. }
  567. /**
  568. * @dev Source of tokens. Override this method to modify the way in which the crowdsale ultimately gets and sends
  569. * its tokens.
  570. * @param beneficiary Address performing the token purchase
  571. * @param tokenAmount Number of tokens to be emitted
  572. */
  573. function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
  574. _token.safeTransfer(beneficiary, tokenAmount);
  575. }
  577. /**
  578. * @dev Executed when a purchase has been validated and is ready to be executed. Doesn't necessarily emit/send
  579. * tokens.
  580. * @param beneficiary Address receiving the tokens
  581. * @param tokenAmount Number of tokens to be purchased
  582. */
  583. function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
  584. _deliverTokens(beneficiary, tokenAmount);
  585. }
  587. /**
  588. * @dev Override for extensions that require an internal state to check for validity (current user contributions,
  589. * etc.)
  590. * @param beneficiary Address receiving the tokens
  591. * @param weiAmount Value in wei involved in the purchase
  592. */
  593. function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
  594. // solhint-disable-previous-line no-empty-blocks
  595. }
  597. /**
  598. * @dev Override to extend the way in which ether is converted to tokens.
  599. * @param weiAmount Value in wei to be converted into tokens
  600. * @return Number of tokens that can be purchased with the specified _weiAmount
  601. */
  602. function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
  603. return weiAmount.mul(_rate);
  604. }
  606. /**
  607. * @dev Determines how ETH is stored/forwarded on purchases.
  608. */
  609. function _forwardFunds() internal {
  610. _wallet.transfer(msg.value);
  611. }
  612. }
  614. pragma solidity ^0.5.0;
  617. /**
  618. * @title AllowanceCrowdsale
  619. * @dev Extension of Crowdsale where tokens are held by a wallet, which approves an allowance to the crowdsale.
  620. */
  621. contract AllowanceCrowdsale is Crowdsale {
  622. using SafeMath for uint256;
  623. using SafeERC20 for IERC20;
  625. address private _tokenWallet;
  627. /**
  628. * @dev Constructor, takes token wallet address.
  629. * @param tokenWallet Address holding the tokens, which has approved allowance to the crowdsale.
  630. */
  631. constructor (address tokenWallet) public {
  632. require(tokenWallet != address(0), "AllowanceCrowdsale: token wallet is the zero address");
  633. _tokenWallet = tokenWallet;
  634. }
  636. /**
  637. * @return the address of the wallet that will hold the tokens.
  638. */
  639. function tokenWallet() public view returns (address) {
  640. return _tokenWallet;
  641. }
  643. /**
  644. * @dev Checks the amount of tokens left in the allowance.
  645. * @return Amount of tokens left in the allowance
  646. */
  647. function remainingTokens() public view returns (uint256) {
  648. return Math.min(token().balanceOf(_tokenWallet), token().allowance(_tokenWallet, address(this)));
  649. }
  651. /**
  652. * @dev Overrides parent behavior by transferring tokens from wallet.
  653. * @param beneficiary Token purchaser
  654. * @param tokenAmount Amount of tokens purchased
  655. */
  656. function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
  657. token().safeTransferFrom(_tokenWallet, beneficiary, tokenAmount);
  658. }
  659. }
  661. pragma solidity ^0.5.0;
  664. /**
  665. * @title TimedCrowdsale
  666. * @dev Crowdsale accepting contributions only within a time frame.
  667. */
  668. contract TimedCrowdsale is Crowdsale {
  669. using SafeMath for uint256;
  671. uint256 private _openingTime;
  672. uint256 private _closingTime;
  674. /**
  675. * Event for crowdsale extending
  676. * @param newClosingTime new closing time
  677. * @param prevClosingTime old closing time
  678. */
  679. event TimedCrowdsaleExtended(uint256 prevClosingTime, uint256 newClosingTime);
  681. /**
  682. * @dev Reverts if not in crowdsale time range.
  683. */
  684. modifier onlyWhileOpen {
  685. require(isOpen(), "TimedCrowdsale: not open");
  686. _;
  687. }
  689. /**
  690. * @dev Constructor, takes crowdsale opening and closing times.
  691. * @param openingTime Crowdsale opening time
  692. * @param closingTime Crowdsale closing time
  693. */
  694. constructor (uint256 openingTime, uint256 closingTime) public {
  695. // solhint-disable-next-line not-rely-on-time
  696. require(openingTime >= block.timestamp, "TimedCrowdsale: opening time is before current time");
  697. // solhint-disable-next-line max-line-length
  698. require(closingTime > openingTime, "TimedCrowdsale: opening time is not before closing time");
  700. _openingTime = openingTime;
  701. _closingTime = closingTime;
  702. }
  704. /**
  705. * @return the crowdsale opening time.
  706. */
  707. function openingTime() public view returns (uint256) {
  708. return _openingTime;
  709. }
  711. /**
  712. * @return the crowdsale closing time.
  713. */
  714. function closingTime() public view returns (uint256) {
  715. return _closingTime;
  716. }
  718. /**
  719. * @return true if the crowdsale is open, false otherwise.
  720. */
  721. function isOpen() public view returns (bool) {
  722. // solhint-disable-next-line not-rely-on-time
  723. return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
  724. }
  726. /**
  727. * @dev Checks whether the period in which the crowdsale is open has already elapsed.
  728. * @return Whether crowdsale period has elapsed
  729. */
  730. function hasClosed() public view returns (bool) {
  731. // solhint-disable-next-line not-rely-on-time
  732. return block.timestamp > _closingTime;
  733. }
  735. /**
  736. * @dev Extend parent behavior requiring to be within contributing period.
  737. * @param beneficiary Token purchaser
  738. * @param weiAmount Amount of wei contributed
  739. */
  740. function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
  741. super._preValidatePurchase(beneficiary, weiAmount);
  742. }
  744. /**
  745. * @dev Extend crowdsale.
  746. * @param newClosingTime Crowdsale closing time
  747. */
  748. function _extendTime(uint256 newClosingTime) internal {
  749. require(!hasClosed(), "TimedCrowdsale: already closed");
  750. // solhint-disable-next-line max-line-length
  751. require(newClosingTime > _closingTime, "TimedCrowdsale: new closing time is before current closing time");
  753. emit TimedCrowdsaleExtended(_closingTime, newClosingTime);
  754. _closingTime = newClosingTime;
  755. }
  756. }
  758. pragma solidity ^0.5.0;
  761. /**
  762. * @title IncreasingPriceCrowdsale
  763. * @dev Extension of Crowdsale contract that increases the price of tokens linearly in time.
  764. * Note that what should be provided to the constructor is the initial and final _rates_, that is,
  765. * the amount of tokens per wei contributed. Thus, the initial rate must be greater than the final rate.
  766. */
  767. contract IncreasingPriceCrowdsale is TimedCrowdsale {
  768. using SafeMath for uint256;
  770. uint256 private _initialRate;
  771. uint256 private _finalRate;
  773. /**
  774. * @dev Constructor, takes initial and final rates of tokens received per wei contributed.
  775. * @param initialRate Number of tokens a buyer gets per wei at the start of the crowdsale
  776. * @param finalRate Number of tokens a buyer gets per wei at the end of the crowdsale
  777. */
  778. constructor (uint256 initialRate, uint256 finalRate) public {
  779. require(finalRate > 0, "IncreasingPriceCrowdsale: final rate is 0");
  780. // solhint-disable-next-line max-line-length
  781. require(initialRate > finalRate, "IncreasingPriceCrowdsale: initial rate is not greater than final rate");
  782. _initialRate = initialRate;
  783. _finalRate = finalRate;
  784. }
  786. /**
  787. * The base rate function is overridden to revert, since this crowdsale doesn't use it, and
  788. * all calls to it are a mistake.
  789. */
  790. function rate() public view returns (uint256) {
  791. revert("IncreasingPriceCrowdsale: rate() called");
  792. }
  794. /**
  795. * @return the initial rate of the crowdsale.
  796. */
  797. function initialRate() public view returns (uint256) {
  798. return _initialRate;
  799. }
  801. /**
  802. * @return the final rate of the crowdsale.
  803. */
  804. function finalRate() public view returns (uint256) {
  805. return _finalRate;
  806. }
  808. /**
  809. * @dev Returns the rate of tokens per wei at the present time.
  810. * Note that, as price _increases_ with time, the rate _decreases_.
  811. * @return The number of tokens a buyer gets per wei at a given time
  812. */
  813. function getCurrentRate() public view returns (uint256) {
  814. if (!isOpen()) {
  815. return 0;
  816. }
  818. // solhint-disable-next-line not-rely-on-time
  819. uint256 elapsedTime = block.timestamp.sub(openingTime());
  820. uint256 timeRange = closingTime().sub(openingTime());
  821. uint256 rateRange = _initialRate.sub(_finalRate);
  822. return _initialRate.sub(elapsedTime.mul(rateRange).div(timeRange));
  823. }
  825. /**
  826. * @dev Overrides parent method taking into account variable rate.
  827. * @param weiAmount The value in wei to be converted into tokens
  828. * @return The number of tokens _weiAmount wei will buy at present time
  829. */
  830. function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
  831. uint256 currentRate = getCurrentRate();
  832. return currentRate.mul(weiAmount);
  833. }
  834. }
  836. contract TestToken is ERC20 {
  837. using SafeMath for uint256;
  839. string public symbol = "TEST";
  840. string public name = "TEST Token";
  841. uint8 public decimals = 18;
  842. uint256 public _totalSupply = 140000000 * 10**uint256(decimals);
  843. }
  846. contract TestCrowdsale is Crowdsale, AllowanceCrowdsale, TimedCrowdsale
  847. {
  848. constructor(
  849. uint256 _openingTime,
  850. uint256 _closingTime,
  851. uint256 _rate,
  852. address _wallet,
  853. address _tokenWallet,
  854. address _token
  855. )
  856. public
  857. AllowanceCrowdsale(_tokenWallet)
  858. TimedCrowdsale(_openingTime, _closingTime)
  859. {
  860. }
  861. }

TestCrowdsale.sol