Common cases

.eslintrc

@@ -8,5 +8,9 @@
   ],
   "parserOptions": {
     "ecmaVersion": 8
+  },
+  "rules": {
+    "arrow-parens": ["error", "always"],
+    "comma-dangle": ["error", "never"]
   }
 }

contracts/Deal.sol

@@ -1,38 +1,31 @@
-pragma solidity ^0.4.15;
-
-
-import '../node_modules/zeppelin-solidity/contracts/crowdsale/Crowdsale.sol';
-import './TxOwnable.sol';
-import './DealToken.sol';
-
-
-contract Deal is Crowdsale, TxOwnable {
-
-  DealToken dealToken;
-  mapping (address => bool) authorized;
-  event Authorizing(address sender, address investor);
-
-  function Deal(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet)
-   Crowdsale(_startTime, _endTime, _rate, _wallet) TxOwnable {
-  }
-
-  // creates the token to be sold.
-  // override this method to have crowdsale of a specific MintableToken token.
-  function createTokenContract() internal returns (MintableToken) {
-//    address dealAddress = address(this);
-//    DealToken(dealAddress, address(token));
-    dealToken = new DealToken();
-    return dealToken;
-  }
-
-  function authorize(address investor) onlyOwner public {
-    Authorizing(msg.sender,investor);
-    dealToken.authorizeAddress(investor,true);
-    authorized[investor] = true;
-  }
-
-
-  function buyTokens(address beneficiary) public payable {
-    return super.buyTokens(beneficiary);
-  }
+pragma solidity ^0.4.21;
+
+import "validated-token/contracts/ReferenceToken.sol";
+import "./Phase/PhasedToken.sol";
+
+contract Deal is PhasedToken, ReferenceToken {
+    constructor(
+        string _name,
+        string _symbol,
+        uint256 _granularity,
+        uint256 _mintStartTime,
+        uint256 _holdStartTime,
+        uint256 _transferStartTime,
+        TokenValidator _validator
+    ) ReferenceToken(_name, _symbol, _granularity, _validator)
+      PhasedToken(_mintStartTime, _holdStartTime, _transferStartTime)
+      public {}
+
+    function mint(address _tokenHolder, uint256 _amount) public onlyOwner {
+        require(isMintPhase());
+        return super.mint(_tokenHolder, _amount);
+    }
+
+    function canTransfer(
+        address _from,
+        address _to,
+        uint256 _amount
+    ) internal returns (bool) {
+        return (isTransferPhase() && super.canTransfer(_from, _to, _amount));
+    }
 }

contracts/DealValidator.sol

@@ -0,0 +1,68 @@
+pragma solidity ^0.4.21;
+
+import "zeppelin-solidity/contracts/math/SafeMath.sol";
+import "validated-token/contracts/TokenValidator.sol";
+import "zeppelin-solidity/contracts/ownership/Ownable.sol";
+
+/*
+   Deal          DealValidator        PhaseValidator
+    |                 |                    |
+    |    check/4      |                    |
+    +---------------> |                    |
+    |                 |     check/4        |
+    |                 +------------------> |
+    |                 |                    |
+    |                 |                    |
+    |                 |    startTime/0     |
+    | <------------------------------------+
+    |                 |    12345           |
+    +------------------------------------> |
+    |                 |                    |
+    |                 |                    |
+    |                 |      endTime/0     |
+    | <------------------------------------+
+    |                 |    67890           |
+    +------------------------------------> |
+    |                 |                    |
+    |                 |                    |
+    |                 |       hex"41"      |
+    |                 | <------------------+
+    |      hex"41"    |                    |
+    | <---------------+                    |
+    |                 |                    |
+    |                 |                    |
+ */
+contract DealValidator is Ownable, TokenValidator {
+    using SafeMath for uint256;
+
+    mapping(address => bool) internal auths;
+
+    constructor() Ownable() public {}
+
+    function setAuth(address _address, bool _status) external onlyOwner {
+        auths[_address] = _status;
+    }
+
+    // TOKEN VALIDATOR //
+
+    function check(address /* _deal */, address _account) external returns (byte _status) {
+        if (auths[_account]) {
+            return hex"11";
+        } else {
+            return hex"10";
+        }
+    }
+
+    function check(
+        address /* _token */,
+        address _from,
+        address _to,
+        uint256 /* _amount */
+    ) external returns (byte _validation) {
+        if (auths[_from] && auths[_to]) {
+            return hex"11";
+        } else {
+            return hex"10";
+        }
+    }
+}

contracts/Migrations.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.4.17;
+pragma solidity ^0.4.21;
 
 contract Migrations {
   address public owner;

contracts/Phase/AdvanceableToken.sol

@@ -0,0 +1,27 @@
+pragma solidity ^0.4.21;
+
+import "zeppelin-solidity/contracts/ownership/Ownable.sol";
+import "./PhasedToken.sol";
+
+contract AdvancableToken is Ownable, PhasedToken {
+    constructor(
+        uint256 _mintStartTime,
+        uint256 _holdStartTime,
+        uint256 _transferStartTime
+    ) PhasedToken(_mintStartTime, _holdStartTime, _transferStartTime) public {}
+
+    function startMintPhase() external onlyOwner {
+        require(now < mintStartTime);
+        mintStartTime = now;
+    }
+
+    function startHoldPhase() external onlyOwner {
+        require(isMintPhase());
+        holdStartTime = now;
+    }
+
+    function startTransferPhase() external onlyOwner {
+        require(isHoldPhase());
+        transferStartTime = now;
+    }
+}

contracts/Phase/Closable.sol

@@ -0,0 +1,14 @@
+pragma solidity ^0.4.21;
+
+contract Closable {
+    uint256 public closingTime;
+
+    constructor(uint256 _closingTime) public {
+        require(_closingTime >= now);
+        closingTime = _closingTime;
+    }
+
+    function isClosed() public view returns (bool) {
+        return now >= closingTime;
+    }
+}

contracts/Phase/PhasedToken.sol

@@ -0,0 +1,64 @@
+pragma solidity ^0.4.21;
+
+import "../Range.sol";
+
+/*
+  LIFECYCLE
+  =========
+
+  |-----------|--------------------|----------------|
+     Minting        Hold Period         Transfer
+*/
+
+contract PhasedToken {
+    using Range for uint256;
+
+    uint256 public mintStartTime;
+    uint256 public holdStartTime;
+    uint256 public transferStartTime;
+
+    enum Phase {
+        Before,
+        Mint,
+        Hold,
+        Transfer
+    }
+
+    constructor(
+        uint256 _mintStartTime,
+        uint256 _holdStartTime,
+        uint256 _transferStartTime
+    ) public {
+        require(now <= _mintStartTime);
+        require(_mintStartTime <= _holdStartTime);
+        require(_holdStartTime <= _transferStartTime);
+
+        mintStartTime  = _mintStartTime;
+        holdStartTime  = _holdStartTime;
+        transferStartTime  = _transferStartTime;
+    }
+
+    function isBeforeMintPhase() public view returns (bool) {
+        return now < mintStartTime;
+    }
+
+    function isMintPhase() public view returns (bool) {
+        return now.isBetween(mintStartTime, holdStartTime);
+    }
+
+    function isHoldPhase() public view returns (bool) {
+        return now.isBetween(holdStartTime, transferStartTime);
+    }
+
+    function isTransferPhase() public view returns (bool) {
+        return now >= transferStartTime;
+    }
+
+    function phase() public view returns (Phase) {
+        if (isBeforeMintPhase()) { return Phase.Before; }
+        if (isMintPhase()) { return Phase.Mint; }
+        if (isHoldPhase()) { return Phase.Hold; }
+        if (isTransferPhase()) { return Phase.Transfer; }
+        revert("Token is in unknown phase");
+    }
+}

contracts/Range.sol

@@ -0,0 +1,11 @@
+pragma solidity ^0.4.21;
+
+library Range {
+    function isBetween(
+        uint256 _subject,
+        uint256 _start,
+        uint256 _end
+    ) internal pure returns (bool) {
+        return (_start <= _subject && _subject < _end);
+    }
+}