contract VestedToken is StandardToken, LimitedTransferToken {

    uint256 MAX_GRANTS_PER_ADDRESS = 20;

    struct TokenGrant {
        address granter;         // 20 bytes
        uint256 value;             // 32 bytes
        uint start;
        uint cliff;
        uint vesting;                // 3 * 8 = 24 bytes
        bool revokable;
        bool burnsOnRevoke;    // 2 * 1 = 2 bits? or 2 bytes?
        bool timeOrNumber;
    } // total 78 bytes = 3 sstore per operation (32 per sstore)

    mapping (address => TokenGrant[]) public grants;

    event NewTokenGrant(address indexed from, address indexed to, uint256 value, uint256 grantId);

    /**
     * @dev Grant tokens to a specified address
     * @param _to address The address which the tokens will be granted to.
     * @param _value uint256 The amount of tokens to be granted.
     * @param _start uint64 Time of the beginning of the grant.
     * @param _cliff uint64 Time of the cliff period.
     * @param _vesting uint64 The vesting period.
     */
    function grantVestedTokens(
        address _to,
        uint256 _value,
        uint _start,
        uint _cliff,
        uint _vesting,
        bool _revokable,
        bool _burnsOnRevoke,
        bool _timeOrNumber
    ) public returns (bool) {

        // Check for date inconsistencies that may cause unexpected behavior
        if (_cliff < _start || _vesting < _cliff) {
            revert();
        }

        // To prevent a user being spammed and have his balance locked (out of gas attack when calculating vesting).
        if (tokenGrantsCount(_to) > MAX_GRANTS_PER_ADDRESS) revert();

        uint count = grants[_to].push(
            TokenGrant(
                _revokable ? msg.sender : 0, // avoid storing an extra 20 bytes when it is non-revokable
                _value,
                _start,
                _cliff,
                _vesting,
                _revokable,
                _burnsOnRevoke,
                _timeOrNumber
            )
        );

        transfer(_to, _value);

        emit NewTokenGrant(msg.sender, _to, _value, count - 1);
        return true;
    }

    /**
     * @dev Revoke the grant of tokens of a specifed address.
     * @param _holder The address which will have its tokens revoked.
     * @param _grantId The id of the token grant.
     */
    function revokeTokenGrant(address _holder, uint _grantId) public returns (bool) {
        TokenGrant storage grant = grants[_holder][_grantId];

        if (!grant.revokable) { // Check if grant was revokable
            revert();
        }

        if (grant.granter != msg.sender) { // Only granter can revoke it
            revert();
        }

        address receiver = grant.burnsOnRevoke ? 0xdead : msg.sender;

        uint256 nonVested = nonVestedTokens(grant, now, block.number);

        // remove grant from array
        delete grants[_holder][_grantId];
        grants[_holder][_grantId] = grants[_holder][grants[_holder].length.sub(1)];
        grants[_holder].length -= 1;

        balances[receiver] = balances[receiver].add(nonVested);
        balances[_holder] = balances[_holder].sub(nonVested);

        emit Transfer(_holder, receiver, nonVested);
        return true;
    }


    /**
     * @dev Calculate the total amount of transferable tokens of a holder at a given time
     * @param holder address The address of the holder
     * @param time uint The specific time.
     * @return An uint representing a holder&#39;s total amount of transferable tokens.
     */
    function transferableTokens(address holder, uint time, uint number) view public returns (uint256) {
        uint256 grantIndex = tokenGrantsCount(holder);

        if (grantIndex == 0) return balanceOf(holder); // shortcut for holder without grants

        // Iterate through all the grants the holder has, and add all non-vested tokens
        uint256 nonVested = 0;
        for (uint256 i = 0; i < grantIndex; i++) {
            nonVested = SafeMath.add(nonVested, nonVestedTokens(grants[holder][i], time, number));
        }

        // Balance - totalNonVested is the amount of tokens a holder can transfer at any given time
        uint256 vestedTransferable = SafeMath.sub(balanceOf(holder), nonVested);

        // Return the minimum of how many vested can transfer and other value
        // in case there are other limiting transferability factors (default is balanceOf)
        return SafeMath.min256(vestedTransferable, super.transferableTokens(holder, time, number));
    }

    /**
     * @dev Check the amount of grants that an address has.
     * @param _holder The holder of the grants.
     * @return A uint representing the total amount of grants.
     */
    function tokenGrantsCount(address _holder) public view returns (uint index) {
        return grants[_holder].length;
    }

    /**
     * @dev Calculate amount of vested tokens at a specifc time.
     * @param tokens uint256 The amount of tokens grantted.
     * @param time uint64 The time to be checked
     * @param start uint64 A time representing the begining of the grant
     * @param cliff uint64 The cliff period.
     * @param vesting uint64 The vesting period.
     * @return An uint representing the amount of vested tokensof a specif grant.
    *  transferableTokens
    *   |                         _/--------   vestedTokens rect
    *   |                       _/
    *   |                     _/
    *   |                   _/
    *   |                 _/
    *   |                /
    *   |              .|
    *   |            .  |
    *   |          .    |
    *   |        .      |
    *   |      .        |
    *   |    .          |
    *   +===+===========+---------+----------> time
    *      Start       Clift    Vesting
    */
    function calculateVestedTokensTime(
        uint256 tokens,
        uint256 time,
        uint256 start,
        uint256 cliff,
        uint256 vesting) public pure returns (uint256) {
        // Shortcuts for before cliff and after vesting cases.
        if (time < cliff) return 0;
        if (time >= vesting) return tokens;

        // Interpolate all vested tokens.
        // As before cliff the shortcut returns 0, we can use just calculate a value
        // in the vesting rect (as shown in above&#39;s figure)

        // vestedTokens = tokens * (time - start) / (vesting - start)
        uint256 vestedTokens = SafeMath.div(SafeMath.mul(tokens, SafeMath.sub(time, start)), SafeMath.sub(vesting, start));

        return vestedTokens;
    }

    function calculateVestedTokensNumber(
        uint256 tokens,
        uint256 number,
        uint256 start,
        uint256 cliff,
        uint256 vesting) public pure returns (uint256) {
        // Shortcuts for before cliff and after vesting cases.
        if (number < cliff) return 0;
        if (number >= vesting) return tokens;

        // Interpolate all vested tokens.
        // As before cliff the shortcut returns 0, we can use just calculate a value
        // in the vesting rect (as shown in above&#39;s figure)

        // vestedTokens = tokens * (number - start) / (vesting - start)
        uint256 vestedTokens = SafeMath.div(SafeMath.mul(tokens, SafeMath.sub(number, start)), SafeMath.sub(vesting, start));

        return vestedTokens;
    }

    function calculateVestedTokens(
        bool timeOrNumber,
        uint256 tokens,
        uint256 time,
        uint256 number,
        uint256 start,
        uint256 cliff,
        uint256 vesting) public pure returns (uint256) {
        if (timeOrNumber) {
            return calculateVestedTokensTime(
                tokens,
                time,
                start,
                cliff,
                vesting
            );
        } else {
            return calculateVestedTokensNumber(
                tokens,
                number,
                start,
                cliff,
                vesting
            );
        }
    }

    /**
     * @dev Get all information about a specifc grant.
     * @param _holder The address which will have its tokens revoked.
     * @param _grantId The id of the token grant.
     * @return Returns all the values that represent a TokenGrant(address, value, start, cliff,
     * revokability, burnsOnRevoke, and vesting) plus the vested value at the current time.
     */
    function tokenGrant(address _holder, uint _grantId) public view 
        returns (address granter, uint256 value, uint256 vested, uint start, uint cliff, uint vesting, bool revokable, bool burnsOnRevoke, bool timeOrNumber) {
        TokenGrant storage grant = grants[_holder][_grantId];

        granter = grant.granter;
        value = grant.value;
        start = grant.start;
        cliff = grant.cliff;
        vesting = grant.vesting;
        revokable = grant.revokable;
        burnsOnRevoke = grant.burnsOnRevoke;
        timeOrNumber = grant.timeOrNumber;

        vested = vestedTokens(grant, now, block.number);
    }

    /**
     * @dev Get the amount of vested tokens at a specific time.
     * @param grant TokenGrant The grant to be checked.
     * @param time The time to be checked
     * @return An uint representing the amount of vested tokens of a specific grant at a specific time.
     */
    function vestedTokens(TokenGrant grant, uint time, uint number) private pure returns (uint256) {
        return calculateVestedTokens(
            grant.timeOrNumber,
            grant.value,
            uint256(time),
            uint256(number),
            uint256(grant.start),
            uint256(grant.cliff),
            uint256(grant.vesting)
        );
    }

    /**
     * @dev Calculate the amount of non vested tokens at a specific time.
     * @param grant TokenGrant The grant to be checked.
     * @param time uint64 The time to be checked
     * @return An uint representing the amount of non vested tokens of a specifc grant on the 
     * passed time frame.
     */
    function nonVestedTokens(TokenGrant grant, uint time, uint number) private pure returns (uint256) {
        return grant.value.sub(vestedTokens(grant, time, number));
    }

    /**
     * @dev Calculate the date when the holder can trasfer all its tokens
     * @param holder address The address of the holder
     * @return An uint representing the date of the last transferable tokens.
     */
    function lastTokenIsTransferableDate(address holder) view public returns (uint date) {
        date = now;
        uint256 grantIndex = grants[holder].length;
        for (uint256 i = 0; i < grantIndex; i++) {
            if (grants[holder][i].timeOrNumber) {
                date = SafeMath.max256(grants[holder][i].vesting, date);
            }
        }
    }
    function lastTokenIsTransferableNumber(address holder) view public returns (uint number) {
        number = block.number;
        uint256 grantIndex = grants[holder].length;
        for (uint256 i = 0; i < grantIndex; i++) {
            if (!grants[holder][i].timeOrNumber) {
                number = SafeMath.max256(grants[holder][i].vesting, number);
            }
        }
    }
}
/**
 * @title Vested token
 * @dev Tokens that can be vested for a group of addresses.
 */
function nonVestedTokens(TokenGrant grant, uint time, uint number) private pure returns (uint256) {
        return grant.value.sub(vestedTokens(grant, time, number));
    }
/**
 * @dev Calculate the amount of non vested tokens at a specific time.
 * @param grant TokenGrant The grant to be checked.
 * @param time uint64 The time to be checked
 * @return An uint representing the amount of non vested tokens of a specifc grant on the 
 * passed time frame.
 */