diff --git a/.soliumrc.json b/.soliumrc.json
index 8fe25b30e..e7f413f9f 100644
--- a/.soliumrc.json
+++ b/.soliumrc.json
@@ -2,12 +2,13 @@
   "extends": "solium:all",
   "plugins": ["security"],
   "rules": {
+    "arg-overflow": "off",
     "blank-lines": "off",
     "error-reason": "off",
-    "indentation": ["error", 2],
+    "indentation": ["error", 4],
     "lbrace": "off",
     "linebreak-style": ["error", "unix"],
-    "max-len": ["error", 79],
+    "max-len": ["error", 120],
     "no-constant": ["error"],
     "no-empty-blocks": "off",
     "quotes": ["error", "double"],
diff --git a/contracts/access/Roles.sol b/contracts/access/Roles.sol
index e3b97ddb7..7b364da53 100644
--- a/contracts/access/Roles.sol
+++ b/contracts/access/Roles.sol
@@ -5,40 +5,36 @@ pragma solidity ^0.4.24;
  * @dev Library for managing addresses assigned to a Role.
  */
 library Roles {
-  struct Role {
-    mapping (address => bool) bearer;
-  }
+    struct Role {
+        mapping (address => bool) bearer;
+    }
 
-  /**
-   * @dev give an account access to this role
-   */
-  function add(Role storage role, address account) internal {
-    require(account != address(0));
-    require(!has(role, account));
+    /**
+     * @dev give an account access to this role
+     */
+    function add(Role storage role, address account) internal {
+        require(account != address(0));
+        require(!has(role, account));
 
-    role.bearer[account] = true;
-  }
+        role.bearer[account] = true;
+    }
 
-  /**
-   * @dev remove an account's access to this role
-   */
-  function remove(Role storage role, address account) internal {
-    require(account != address(0));
-    require(has(role, account));
+    /**
+     * @dev remove an account's access to this role
+     */
+    function remove(Role storage role, address account) internal {
+        require(account != address(0));
+        require(has(role, account));
 
-    role.bearer[account] = false;
-  }
+        role.bearer[account] = false;
+    }
 
-  /**
-   * @dev check if an account has this role
-   * @return bool
-   */
-  function has(Role storage role, address account)
-    internal
-    view
-    returns (bool)
-  {
-    require(account != address(0));
-    return role.bearer[account];
-  }
+    /**
+     * @dev check if an account has this role
+     * @return bool
+     */
+    function has(Role storage role, address account) internal view returns (bool) {
+        require(account != address(0));
+        return role.bearer[account];
+    }
 }
diff --git a/contracts/access/roles/CapperRole.sol b/contracts/access/roles/CapperRole.sol
index 25c2d7c73..7307abce1 100644
--- a/contracts/access/roles/CapperRole.sol
+++ b/contracts/access/roles/CapperRole.sol
@@ -3,41 +3,41 @@ pragma solidity ^0.4.24;
 import "../Roles.sol";
 
 contract CapperRole {
-  using Roles for Roles.Role;
+    using Roles for Roles.Role;
 
-  event CapperAdded(address indexed account);
-  event CapperRemoved(address indexed account);
+    event CapperAdded(address indexed account);
+    event CapperRemoved(address indexed account);
 
-  Roles.Role private _cappers;
+    Roles.Role private _cappers;
 
-  constructor() internal {
-    _addCapper(msg.sender);
-  }
+    constructor () internal {
+        _addCapper(msg.sender);
+    }
 
-  modifier onlyCapper() {
-    require(isCapper(msg.sender));
-    _;
-  }
+    modifier onlyCapper() {
+        require(isCapper(msg.sender));
+        _;
+    }
 
-  function isCapper(address account) public view returns (bool) {
-    return _cappers.has(account);
-  }
+    function isCapper(address account) public view returns (bool) {
+        return _cappers.has(account);
+    }
 
-  function addCapper(address account) public onlyCapper {
-    _addCapper(account);
-  }
+    function addCapper(address account) public onlyCapper {
+        _addCapper(account);
+    }
 
-  function renounceCapper() public {
-    _removeCapper(msg.sender);
-  }
+    function renounceCapper() public {
+        _removeCapper(msg.sender);
+    }
 
-  function _addCapper(address account) internal {
-    _cappers.add(account);
-    emit CapperAdded(account);
-  }
+    function _addCapper(address account) internal {
+        _cappers.add(account);
+        emit CapperAdded(account);
+    }
 
-  function _removeCapper(address account) internal {
-    _cappers.remove(account);
-    emit CapperRemoved(account);
-  }
+    function _removeCapper(address account) internal {
+        _cappers.remove(account);
+        emit CapperRemoved(account);
+    }
 }
diff --git a/contracts/access/roles/MinterRole.sol b/contracts/access/roles/MinterRole.sol
index 450f69652..c4234c5bc 100644
--- a/contracts/access/roles/MinterRole.sol
+++ b/contracts/access/roles/MinterRole.sol
@@ -3,41 +3,41 @@ pragma solidity ^0.4.24;
 import "../Roles.sol";
 
 contract MinterRole {
-  using Roles for Roles.Role;
+    using Roles for Roles.Role;
 
-  event MinterAdded(address indexed account);
-  event MinterRemoved(address indexed account);
+    event MinterAdded(address indexed account);
+    event MinterRemoved(address indexed account);
 
-  Roles.Role private _minters;
+    Roles.Role private _minters;
 
-  constructor() internal {
-    _addMinter(msg.sender);
-  }
+    constructor () internal {
+        _addMinter(msg.sender);
+    }
 
-  modifier onlyMinter() {
-    require(isMinter(msg.sender));
-    _;
-  }
+    modifier onlyMinter() {
+        require(isMinter(msg.sender));
+        _;
+    }
 
-  function isMinter(address account) public view returns (bool) {
-    return _minters.has(account);
-  }
+    function isMinter(address account) public view returns (bool) {
+        return _minters.has(account);
+    }
 
-  function addMinter(address account) public onlyMinter {
-    _addMinter(account);
-  }
+    function addMinter(address account) public onlyMinter {
+        _addMinter(account);
+    }
 
-  function renounceMinter() public {
-    _removeMinter(msg.sender);
-  }
+    function renounceMinter() public {
+        _removeMinter(msg.sender);
+    }
 
-  function _addMinter(address account) internal {
-    _minters.add(account);
-    emit MinterAdded(account);
-  }
+    function _addMinter(address account) internal {
+        _minters.add(account);
+        emit MinterAdded(account);
+    }
 
-  function _removeMinter(address account) internal {
-    _minters.remove(account);
-    emit MinterRemoved(account);
-  }
+    function _removeMinter(address account) internal {
+        _minters.remove(account);
+        emit MinterRemoved(account);
+    }
 }
diff --git a/contracts/access/roles/PauserRole.sol b/contracts/access/roles/PauserRole.sol
index 698bb8769..5963feffd 100644
--- a/contracts/access/roles/PauserRole.sol
+++ b/contracts/access/roles/PauserRole.sol
@@ -3,41 +3,41 @@ pragma solidity ^0.4.24;
 import "../Roles.sol";
 
 contract PauserRole {
-  using Roles for Roles.Role;
+    using Roles for Roles.Role;
 
-  event PauserAdded(address indexed account);
-  event PauserRemoved(address indexed account);
+    event PauserAdded(address indexed account);
+    event PauserRemoved(address indexed account);
 
-  Roles.Role private _pausers;
+    Roles.Role private _pausers;
 
-  constructor() internal {
-    _addPauser(msg.sender);
-  }
+    constructor () internal {
+        _addPauser(msg.sender);
+    }
 
-  modifier onlyPauser() {
-    require(isPauser(msg.sender));
-    _;
-  }
+    modifier onlyPauser() {
+        require(isPauser(msg.sender));
+        _;
+    }
 
-  function isPauser(address account) public view returns (bool) {
-    return _pausers.has(account);
-  }
+    function isPauser(address account) public view returns (bool) {
+        return _pausers.has(account);
+    }
 
-  function addPauser(address account) public onlyPauser {
-    _addPauser(account);
-  }
+    function addPauser(address account) public onlyPauser {
+        _addPauser(account);
+    }
 
-  function renouncePauser() public {
-    _removePauser(msg.sender);
-  }
+    function renouncePauser() public {
+        _removePauser(msg.sender);
+    }
 
-  function _addPauser(address account) internal {
-    _pausers.add(account);
-    emit PauserAdded(account);
-  }
+    function _addPauser(address account) internal {
+        _pausers.add(account);
+        emit PauserAdded(account);
+    }
 
-  function _removePauser(address account) internal {
-    _pausers.remove(account);
-    emit PauserRemoved(account);
-  }
+    function _removePauser(address account) internal {
+        _pausers.remove(account);
+        emit PauserRemoved(account);
+    }
 }
diff --git a/contracts/access/roles/SignerRole.sol b/contracts/access/roles/SignerRole.sol
index 8d76b831f..0dc182705 100644
--- a/contracts/access/roles/SignerRole.sol
+++ b/contracts/access/roles/SignerRole.sol
@@ -3,41 +3,41 @@ pragma solidity ^0.4.24;
 import "../Roles.sol";
 
 contract SignerRole {
-  using Roles for Roles.Role;
+    using Roles for Roles.Role;
 
-  event SignerAdded(address indexed account);
-  event SignerRemoved(address indexed account);
+    event SignerAdded(address indexed account);
+    event SignerRemoved(address indexed account);
 
-  Roles.Role private _signers;
+    Roles.Role private _signers;
 
-  constructor() internal {
-    _addSigner(msg.sender);
-  }
+    constructor () internal {
+        _addSigner(msg.sender);
+    }
 
-  modifier onlySigner() {
-    require(isSigner(msg.sender));
-    _;
-  }
+    modifier onlySigner() {
+        require(isSigner(msg.sender));
+        _;
+    }
 
-  function isSigner(address account) public view returns (bool) {
-    return _signers.has(account);
-  }
+    function isSigner(address account) public view returns (bool) {
+        return _signers.has(account);
+    }
 
-  function addSigner(address account) public onlySigner {
-    _addSigner(account);
-  }
+    function addSigner(address account) public onlySigner {
+        _addSigner(account);
+    }
 
-  function renounceSigner() public {
-    _removeSigner(msg.sender);
-  }
+    function renounceSigner() public {
+        _removeSigner(msg.sender);
+    }
 
-  function _addSigner(address account) internal {
-    _signers.add(account);
-    emit SignerAdded(account);
-  }
+    function _addSigner(address account) internal {
+        _signers.add(account);
+        emit SignerAdded(account);
+    }
 
-  function _removeSigner(address account) internal {
-    _signers.remove(account);
-    emit SignerRemoved(account);
-  }
+    function _removeSigner(address account) internal {
+        _signers.remove(account);
+        emit SignerRemoved(account);
+    }
 }
diff --git a/contracts/crowdsale/Crowdsale.sol b/contracts/crowdsale/Crowdsale.sol
index a0c227607..451f902de 100644
--- a/contracts/crowdsale/Crowdsale.sol
+++ b/contracts/crowdsale/Crowdsale.sol
@@ -18,224 +18,184 @@ import "../utils/ReentrancyGuard.sol";
  * behavior.
  */
 contract Crowdsale is ReentrancyGuard {
-  using SafeMath for uint256;
-  using SafeERC20 for IERC20;
+    using SafeMath for uint256;
+    using SafeERC20 for IERC20;
 
-  // The token being sold
-  IERC20 private _token;
+    // The token being sold
+    IERC20 private _token;
 
-  // Address where funds are collected
-  address private _wallet;
+    // Address where funds are collected
+    address private _wallet;
 
-  // How many token units a buyer gets per wei.
-  // The rate is the conversion between wei and the smallest and indivisible token unit.
-  // So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
-  // 1 wei will give you 1 unit, or 0.001 TOK.
-  uint256 private _rate;
+    // How many token units a buyer gets per wei.
+    // The rate is the conversion between wei and the smallest and indivisible token unit.
+    // So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
+    // 1 wei will give you 1 unit, or 0.001 TOK.
+    uint256 private _rate;
 
-  // Amount of wei raised
-  uint256 private _weiRaised;
+    // Amount of wei raised
+    uint256 private _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 TokensPurchased(
-    address indexed purchaser,
-    address indexed beneficiary,
-    uint256 value,
-    uint256 amount
-  );
+    /**
+     * 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 TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
 
-  /**
-   * @param rate Number of token units a buyer gets per wei
-   * @dev The rate is the conversion between wei and the smallest and indivisible
-   * token unit. So, if you are using a rate of 1 with a ERC20Detailed token
-   * with 3 decimals called TOK, 1 wei will give you 1 unit, or 0.001 TOK.
-   * @param wallet Address where collected funds will be forwarded to
-   * @param token Address of the token being sold
-   */
-  constructor(uint256 rate, address wallet, IERC20 token) internal {
-    require(rate > 0);
-    require(wallet != address(0));
-    require(token != address(0));
+    /**
+     * @param rate Number of token units a buyer gets per wei
+     * @dev The rate is the conversion between wei and the smallest and indivisible
+     * token unit. So, if you are using a rate of 1 with a ERC20Detailed token
+     * with 3 decimals called TOK, 1 wei will give you 1 unit, or 0.001 TOK.
+     * @param wallet Address where collected funds will be forwarded to
+     * @param token Address of the token being sold
+     */
+    constructor (uint256 rate, address wallet, IERC20 token) internal {
+        require(rate > 0);
+        require(wallet != address(0));
+        require(token != address(0));
 
-    _rate = rate;
-    _wallet = wallet;
-    _token = token;
-  }
+        _rate = rate;
+        _wallet = wallet;
+        _token = token;
+    }
 
-  // -----------------------------------------
-  // Crowdsale external interface
-  // -----------------------------------------
+    // -----------------------------------------
+    // Crowdsale external interface
+    // -----------------------------------------
 
-  /**
-   * @dev fallback function ***DO NOT OVERRIDE***
-   * Note that other contracts will transfer fund with a base gas stipend
-   * of 2300, which is not enough to call buyTokens. Consider calling
-   * buyTokens directly when purchasing tokens from a contract.
-   */
-  function () external payable {
-    buyTokens(msg.sender);
-  }
+    /**
+     * @dev fallback function ***DO NOT OVERRIDE***
+     * Note that other contracts will transfer fund with a base gas stipend
+     * of 2300, which is not enough to call buyTokens. Consider calling
+     * buyTokens directly when purchasing tokens from a contract.
+     */
+    function () external payable {
+        buyTokens(msg.sender);
+    }
 
-  /**
-   * @return the token being sold.
-   */
-  function token() public view returns(IERC20) {
-    return _token;
-  }
+    /**
+     * @return the token being sold.
+     */
+    function token() public view returns (IERC20) {
+        return _token;
+    }
 
-  /**
-   * @return the address where funds are collected.
-   */
-  function wallet() public view returns(address) {
-    return _wallet;
-  }
+    /**
+     * @return the address where funds are collected.
+     */
+    function wallet() public view returns (address) {
+        return _wallet;
+    }
 
-  /**
-   * @return the number of token units a buyer gets per wei.
-   */
-  function rate() public view returns(uint256) {
-    return _rate;
-  }
+    /**
+     * @return the number of token units a buyer gets per wei.
+     */
+    function rate() public view returns (uint256) {
+        return _rate;
+    }
 
-  /**
-   * @return the amount of wei raised.
-   */
-  function weiRaised() public view returns (uint256) {
-    return _weiRaised;
-  }
+    /**
+     * @return the amount of wei raised.
+     */
+    function weiRaised() public view returns (uint256) {
+        return _weiRaised;
+    }
 
-  /**
-   * @dev low level token purchase ***DO NOT OVERRIDE***
-   * This function has a non-reentrancy guard, so it shouldn't be called by
-   * another `nonReentrant` function.
-   * @param beneficiary Recipient of the token purchase
-   */
-  function buyTokens(address beneficiary) public nonReentrant payable {
+    /**
+     * @dev low level token purchase ***DO NOT OVERRIDE***
+     * This function has a non-reentrancy guard, so it shouldn't be called by
+     * another `nonReentrant` function.
+     * @param beneficiary Recipient of the token purchase
+     */
+    function buyTokens(address beneficiary) public nonReentrant payable {
+        uint256 weiAmount = msg.value;
+        _preValidatePurchase(beneficiary, weiAmount);
 
-    uint256 weiAmount = msg.value;
-    _preValidatePurchase(beneficiary, weiAmount);
+        // calculate token amount to be created
+        uint256 tokens = _getTokenAmount(weiAmount);
 
-    // calculate token amount to be created
-    uint256 tokens = _getTokenAmount(weiAmount);
+        // update state
+        _weiRaised = _weiRaised.add(weiAmount);
 
-    // update state
-    _weiRaised = _weiRaised.add(weiAmount);
+        _processPurchase(beneficiary, tokens);
+        emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
 
-    _processPurchase(beneficiary, tokens);
-    emit TokensPurchased(
-      msg.sender,
-      beneficiary,
-      weiAmount,
-      tokens
-    );
+        _updatePurchasingState(beneficiary, weiAmount);
 
-    _updatePurchasingState(beneficiary, weiAmount);
+        _forwardFunds();
+        _postValidatePurchase(beneficiary, weiAmount);
+    }
 
-    _forwardFunds();
-    _postValidatePurchase(beneficiary, weiAmount);
-  }
+    // -----------------------------------------
+    // Internal interface (extensible)
+    // -----------------------------------------
 
-  // -----------------------------------------
-  // Internal interface (extensible)
-  // -----------------------------------------
+    /**
+     * @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met. Use `super` in contracts that inherit from Crowdsale to extend their validations.
+     * Example from CappedCrowdsale.sol's _preValidatePurchase method:
+     *     super._preValidatePurchase(beneficiary, weiAmount);
+     *     require(weiRaised().add(weiAmount) <= cap);
+     * @param beneficiary Address performing the token purchase
+     * @param weiAmount Value in wei involved in the purchase
+     */
+    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
+        require(beneficiary != address(0));
+        require(weiAmount != 0);
+    }
 
-  /**
-   * @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met. Use `super` in contracts that inherit from Crowdsale to extend their validations.
-   * Example from CappedCrowdsale.sol's _preValidatePurchase method:
-   *   super._preValidatePurchase(beneficiary, weiAmount);
-   *   require(weiRaised().add(weiAmount) <= cap);
-   * @param beneficiary Address performing the token purchase
-   * @param weiAmount Value in wei involved in the purchase
-   */
-  function _preValidatePurchase(
-    address beneficiary,
-    uint256 weiAmount
-  )
-    internal
-    view
-  {
-    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 view {
+        // optional override
+    }
 
-  /**
-   * @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
-    view
-  {
-    // 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.safeTransfer(beneficiary, tokenAmount);
+    }
 
-  /**
-   * @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.safeTransfer(beneficiary, tokenAmount);
-  }
+    /**
+     * @dev Executed when a purchase has been validated and is ready to be executed. Doesn't necessarily emit/send 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 Executed when a purchase has been validated and is ready to be executed. Doesn't necessarily emit/send 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 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 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);
-  }
+    /**
+     * @dev Determines how ETH is stored/forwarded on purchases.
+     */
+    function _forwardFunds() internal {
+        _wallet.transfer(msg.value);
+    }
 }
diff --git a/contracts/crowdsale/distribution/FinalizableCrowdsale.sol b/contracts/crowdsale/distribution/FinalizableCrowdsale.sol
index 8add165da..22ae5ba05 100644
--- a/contracts/crowdsale/distribution/FinalizableCrowdsale.sol
+++ b/contracts/crowdsale/distribution/FinalizableCrowdsale.sol
@@ -9,42 +9,41 @@ import "../validation/TimedCrowdsale.sol";
  * can do extra work after finishing.
  */
 contract FinalizableCrowdsale is TimedCrowdsale {
-  using SafeMath for uint256;
+    using SafeMath for uint256;
 
-  bool private _finalized;
+    bool private _finalized;
 
-  event CrowdsaleFinalized();
+    event CrowdsaleFinalized();
 
-  constructor() internal {
-    _finalized = false;
-  }
+    constructor () internal {
+        _finalized = false;
+    }
 
-  /**
-   * @return true if the crowdsale is finalized, false otherwise.
-   */
-  function finalized() public view returns (bool) {
-    return _finalized;
-  }
+    /**
+     * @return true if the crowdsale is finalized, false otherwise.
+     */
+    function finalized() public view returns (bool) {
+        return _finalized;
+    }
 
-  /**
-   * @dev Must be called after crowdsale ends, to do some extra finalization
-   * work. Calls the contract's finalization function.
-   */
-  function finalize() public {
-    require(!_finalized);
-    require(hasClosed());
+    /**
+     * @dev Must be called after crowdsale ends, to do some extra finalization
+     * work. Calls the contract's finalization function.
+     */
+    function finalize() public {
+        require(!_finalized);
+        require(hasClosed());
 
-    _finalized = true;
+        _finalized = true;
 
-    _finalization();
-    emit CrowdsaleFinalized();
-  }
+        _finalization();
+        emit CrowdsaleFinalized();
+    }
 
-  /**
-   * @dev Can be overridden to add finalization logic. The overriding function
-   * should call super._finalization() to ensure the chain of finalization is
-   * executed entirely.
-   */
-  function _finalization() internal {
-  }
+    /**
+     * @dev Can be overridden to add finalization logic. The overriding function
+     * should call super._finalization() to ensure the chain of finalization is
+     * executed entirely.
+     */
+    function _finalization() internal {}
 }
diff --git a/contracts/crowdsale/distribution/PostDeliveryCrowdsale.sol b/contracts/crowdsale/distribution/PostDeliveryCrowdsale.sol
index b8c9ede77..9d4de3b09 100644
--- a/contracts/crowdsale/distribution/PostDeliveryCrowdsale.sol
+++ b/contracts/crowdsale/distribution/PostDeliveryCrowdsale.sol
@@ -8,43 +8,38 @@ import "../../math/SafeMath.sol";
  * @dev Crowdsale that locks tokens from withdrawal until it ends.
  */
 contract PostDeliveryCrowdsale is TimedCrowdsale {
-  using SafeMath for uint256;
+    using SafeMath for uint256;
 
-  mapping(address => uint256) private _balances;
+    mapping(address => uint256) private _balances;
 
-  constructor() internal {}
+    constructor () internal {}
 
-  /**
-   * @dev Withdraw tokens only after crowdsale ends.
-   * @param beneficiary Whose tokens will be withdrawn.
-   */
-  function withdrawTokens(address beneficiary) public {
-    require(hasClosed());
-    uint256 amount = _balances[beneficiary];
-    require(amount > 0);
-    _balances[beneficiary] = 0;
-    _deliverTokens(beneficiary, amount);
-  }
+    /**
+     * @dev Withdraw tokens only after crowdsale ends.
+     * @param beneficiary Whose tokens will be withdrawn.
+     */
+    function withdrawTokens(address beneficiary) public {
+        require(hasClosed());
+        uint256 amount = _balances[beneficiary];
+        require(amount > 0);
+        _balances[beneficiary] = 0;
+        _deliverTokens(beneficiary, amount);
+    }
 
-  /**
-   * @return the balance of an account.
-   */
-  function balanceOf(address account) public view returns(uint256) {
-    return _balances[account];
-  }
+    /**
+     * @return the balance of an account.
+     */
+    function balanceOf(address account) public view returns (uint256) {
+        return _balances[account];
+    }
 
-  /**
-   * @dev Overrides parent by storing balances instead of issuing tokens right away.
-   * @param beneficiary Token purchaser
-   * @param tokenAmount Amount of tokens purchased
-   */
-  function _processPurchase(
-    address beneficiary,
-    uint256 tokenAmount
-  )
-    internal
-  {
-    _balances[beneficiary] = _balances[beneficiary].add(tokenAmount);
-  }
+    /**
+     * @dev Overrides parent by storing balances instead of issuing tokens right away.
+     * @param beneficiary Token purchaser
+     * @param tokenAmount Amount of tokens purchased
+     */
+    function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
+        _balances[beneficiary] = _balances[beneficiary].add(tokenAmount);
+    }
 
 }
diff --git a/contracts/crowdsale/distribution/RefundableCrowdsale.sol b/contracts/crowdsale/distribution/RefundableCrowdsale.sol
index da02baee6..6c5365cc1 100644
--- a/contracts/crowdsale/distribution/RefundableCrowdsale.sol
+++ b/contracts/crowdsale/distribution/RefundableCrowdsale.sol
@@ -8,84 +8,83 @@ import "../../payment/escrow/RefundEscrow.sol";
  * @title RefundableCrowdsale
  * @dev Extension of Crowdsale contract that adds a funding goal, and
  * the possibility of users getting a refund if goal is not met.
- * WARNING: note that if you allow tokens to be traded before the goal 
- * is met, then an attack is possible in which the attacker purchases 
- * tokens from the crowdsale and when they sees that the goal is 
+ * WARNING: note that if you allow tokens to be traded before the goal
+ * is met, then an attack is possible in which the attacker purchases
+ * tokens from the crowdsale and when they sees that the goal is
  * unlikely to be met, they sell their tokens (possibly at a discount).
  * The attacker will be refunded when the crowdsale is finalized, and
- * the users that purchased from them will be left with worthless 
+ * the users that purchased from them will be left with worthless
  * tokens. There are many possible ways to avoid this, like making the
- * the crowdsale inherit from PostDeliveryCrowdsale, or imposing 
+ * the crowdsale inherit from PostDeliveryCrowdsale, or imposing
  * restrictions on token trading until the crowdsale is finalized.
- * This is being discussed in 
+ * This is being discussed in
  * https://github.com/OpenZeppelin/openzeppelin-solidity/issues/877
  * This contract will be updated when we agree on a general solution
  * for this problem.
  */
 contract RefundableCrowdsale is FinalizableCrowdsale {
-  using SafeMath for uint256;
+    using SafeMath for uint256;
 
-  // minimum amount of funds to be raised in weis
-  uint256 private _goal;
+    // minimum amount of funds to be raised in weis
+    uint256 private _goal;
 
-  // refund escrow used to hold funds while crowdsale is running
-  RefundEscrow private _escrow;
+    // refund escrow used to hold funds while crowdsale is running
+    RefundEscrow private _escrow;
 
-  /**
-   * @dev Constructor, creates RefundEscrow.
-   * @param goal Funding goal
-   */
-  constructor(uint256 goal) internal {
-    require(goal > 0);
-    _escrow = new RefundEscrow(wallet());
-    _goal = goal;
-  }
-
-  /**
-   * @return minimum amount of funds to be raised in wei.
-   */
-  function goal() public view returns(uint256) {
-    return _goal;
-  }
-
-  /**
-   * @dev Investors can claim refunds here if crowdsale is unsuccessful
-   * @param refundee Whose refund will be claimed.
-   */
-  function claimRefund(address refundee) public {
-    require(finalized());
-    require(!goalReached());
-
-    _escrow.withdraw(refundee);
-  }
-
-  /**
-   * @dev Checks whether funding goal was reached.
-   * @return Whether funding goal was reached
-   */
-  function goalReached() public view returns (bool) {
-    return weiRaised() >= _goal;
-  }
-
-  /**
-   * @dev escrow finalization task, called when finalize() is called
-   */
-  function _finalization() internal {
-    if (goalReached()) {
-      _escrow.close();
-      _escrow.beneficiaryWithdraw();
-    } else {
-      _escrow.enableRefunds();
+    /**
+     * @dev Constructor, creates RefundEscrow.
+     * @param goal Funding goal
+     */
+    constructor (uint256 goal) internal {
+        require(goal > 0);
+        _escrow = new RefundEscrow(wallet());
+        _goal = goal;
     }
 
-    super._finalization();
-  }
+    /**
+     * @return minimum amount of funds to be raised in wei.
+     */
+    function goal() public view returns (uint256) {
+        return _goal;
+    }
 
-  /**
-   * @dev Overrides Crowdsale fund forwarding, sending funds to escrow.
-   */
-  function _forwardFunds() internal {
-    _escrow.deposit.value(msg.value)(msg.sender);
-  }
+    /**
+     * @dev Investors can claim refunds here if crowdsale is unsuccessful
+     * @param refundee Whose refund will be claimed.
+     */
+    function claimRefund(address refundee) public {
+        require(finalized());
+        require(!goalReached());
 
+        _escrow.withdraw(refundee);
+    }
+
+    /**
+     * @dev Checks whether funding goal was reached.
+     * @return Whether funding goal was reached
+     */
+    function goalReached() public view returns (bool) {
+        return weiRaised() >= _goal;
+    }
+
+    /**
+     * @dev escrow finalization task, called when finalize() is called
+     */
+    function _finalization() internal {
+        if (goalReached()) {
+            _escrow.close();
+            _escrow.beneficiaryWithdraw();
+        } else {
+            _escrow.enableRefunds();
+        }
+
+        super._finalization();
+    }
+
+    /**
+     * @dev Overrides Crowdsale fund forwarding, sending funds to escrow.
+     */
+    function _forwardFunds() internal {
+        _escrow.deposit.value(msg.value)(msg.sender);
+    }
 }
diff --git a/contracts/crowdsale/emission/AllowanceCrowdsale.sol b/contracts/crowdsale/emission/AllowanceCrowdsale.sol
index 346275c7d..b0c09c744 100644
--- a/contracts/crowdsale/emission/AllowanceCrowdsale.sol
+++ b/contracts/crowdsale/emission/AllowanceCrowdsale.sol
@@ -11,49 +11,41 @@ import "../../math/Math.sol";
  * @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;
-  using SafeERC20 for IERC20;
+    using SafeMath for uint256;
+    using SafeERC20 for IERC20;
 
-  address private _tokenWallet;
+    address private _tokenWallet;
 
-  /**
-   * @dev Constructor, takes token wallet address.
-   * @param tokenWallet Address holding the tokens, which has approved allowance to the crowdsale
-   */
-  constructor(address tokenWallet) internal {
-    require(tokenWallet != address(0));
-    _tokenWallet = tokenWallet;
-  }
+    /**
+     * @dev Constructor, takes token wallet address.
+     * @param tokenWallet Address holding the tokens, which has approved allowance to the crowdsale
+     */
+    constructor (address tokenWallet) internal {
+        require(tokenWallet != address(0));
+        _tokenWallet = tokenWallet;
+    }
 
-  /**
-   * @return the address of the wallet that will hold the tokens.
-   */
-  function tokenWallet() public view returns(address) {
-    return _tokenWallet;
-  }
+    /**
+     * @return the address of the wallet that will hold the tokens.
+     */
+    function tokenWallet() public view returns (address) {
+        return _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 Math.min(
-      token().balanceOf(_tokenWallet),
-      token().allowance(_tokenWallet, this)
-    );
-  }
+    /**
+     * @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 Math.min(token().balanceOf(_tokenWallet), 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().safeTransferFrom(_tokenWallet, beneficiary, tokenAmount);
-  }
+    /**
+     * @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().safeTransferFrom(_tokenWallet, beneficiary, tokenAmount);
+    }
 }
diff --git a/contracts/crowdsale/emission/MintedCrowdsale.sol b/contracts/crowdsale/emission/MintedCrowdsale.sol
index 3ebea857d..1f346a819 100644
--- a/contracts/crowdsale/emission/MintedCrowdsale.sol
+++ b/contracts/crowdsale/emission/MintedCrowdsale.sol
@@ -9,21 +9,15 @@ import "../../token/ERC20/ERC20Mintable.sol";
  * Token ownership should be transferred to MintedCrowdsale for minting.
  */
 contract MintedCrowdsale is Crowdsale {
-  constructor() internal {}
+    constructor () internal {}
 
-  /**
-   * @dev Overrides delivery by minting tokens upon purchase.
-   * @param beneficiary Token purchaser
-   * @param tokenAmount Number of tokens to be minted
-   */
-  function _deliverTokens(
-    address beneficiary,
-    uint256 tokenAmount
-  )
-    internal
-  {
-    // Potentially dangerous assumption about the type of the token.
-    require(
-      ERC20Mintable(address(token())).mint(beneficiary, tokenAmount));
-  }
+    /**
+     * @dev Overrides delivery by minting tokens upon purchase.
+     * @param beneficiary Token purchaser
+     * @param tokenAmount Number of tokens to be minted
+     */
+    function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
+        // Potentially dangerous assumption about the type of the token.
+        require(ERC20Mintable(address(token())).mint(beneficiary, tokenAmount));
+    }
 }
diff --git a/contracts/crowdsale/price/IncreasingPriceCrowdsale.sol b/contracts/crowdsale/price/IncreasingPriceCrowdsale.sol
index c86353c0f..5ac7731a5 100644
--- a/contracts/crowdsale/price/IncreasingPriceCrowdsale.sol
+++ b/contracts/crowdsale/price/IncreasingPriceCrowdsale.sol
@@ -10,72 +10,69 @@ import "../../math/SafeMath.sol";
  * the amount of tokens per wei contributed. Thus, the initial rate must be greater than the final rate.
  */
 contract IncreasingPriceCrowdsale is TimedCrowdsale {
-  using SafeMath for uint256;
+    using SafeMath for uint256;
 
-  uint256 private _initialRate;
-  uint256 private _finalRate;
+    uint256 private _initialRate;
+    uint256 private _finalRate;
 
-  /**
-   * @dev Constructor, takes initial and final rates of tokens received per wei contributed.
-   * @param initialRate Number of tokens a buyer gets per wei at the start of the crowdsale
-   * @param finalRate Number of tokens a buyer gets per wei at the end of the crowdsale
-   */
-  constructor(uint256 initialRate, uint256 finalRate) internal {
-    require(finalRate > 0);
-    require(initialRate > finalRate);
-    _initialRate = initialRate;
-    _finalRate = finalRate;
-  }
-
-  /**
-   * The base rate function is overridden to revert, since this crowdsale doens't use it, and
-   * all calls to it are a mistake.
-   */
-  function rate() public view returns(uint256) {
-    revert();
-  }
-
-  /**
-   * @return the initial rate of the crowdsale.
-   */
-  function initialRate() public view returns(uint256) {
-    return _initialRate;
-  }
-
-  /**
-   * @return the final rate of the crowdsale.
-   */
-  function finalRate() public view returns (uint256) {
-    return _finalRate;
-  }
-
-  /**
-   * @dev Returns the rate of tokens per wei at the present time.
-   * Note that, as price _increases_ with time, the rate _decreases_.
-   * @return The number of tokens a buyer gets per wei at a given time
-   */
-  function getCurrentRate() public view returns (uint256) {
-    if (!isOpen()) {
-      return 0;
+    /**
+     * @dev Constructor, takes initial and final rates of tokens received per wei contributed.
+     * @param initialRate Number of tokens a buyer gets per wei at the start of the crowdsale
+     * @param finalRate Number of tokens a buyer gets per wei at the end of the crowdsale
+     */
+    constructor (uint256 initialRate, uint256 finalRate) internal {
+        require(finalRate > 0);
+        require(initialRate > finalRate);
+        _initialRate = initialRate;
+        _finalRate = finalRate;
     }
 
-    // solium-disable-next-line security/no-block-members
-    uint256 elapsedTime = block.timestamp.sub(openingTime());
-    uint256 timeRange = closingTime().sub(openingTime());
-    uint256 rateRange = _initialRate.sub(_finalRate);
-    return _initialRate.sub(elapsedTime.mul(rateRange).div(timeRange));
-  }
+    /**
+     * The base rate function is overridden to revert, since this crowdsale doens't use it, and
+     * all calls to it are a mistake.
+     */
+    function rate() public view returns (uint256) {
+        revert();
+    }
 
-  /**
-   * @dev Overrides parent method taking into account variable rate.
-   * @param weiAmount The value in wei to be converted into tokens
-   * @return The number of tokens _weiAmount wei will buy at present time
-   */
-  function _getTokenAmount(uint256 weiAmount)
-    internal view returns (uint256)
-  {
-    uint256 currentRate = getCurrentRate();
-    return currentRate.mul(weiAmount);
-  }
+    /**
+     * @return the initial rate of the crowdsale.
+     */
+    function initialRate() public view returns (uint256) {
+        return _initialRate;
+    }
 
+    /**
+     * @return the final rate of the crowdsale.
+     */
+    function finalRate() public view returns (uint256) {
+        return _finalRate;
+    }
+
+    /**
+     * @dev Returns the rate of tokens per wei at the present time.
+     * Note that, as price _increases_ with time, the rate _decreases_.
+     * @return The number of tokens a buyer gets per wei at a given time
+     */
+    function getCurrentRate() public view returns (uint256) {
+        if (!isOpen()) {
+            return 0;
+        }
+
+        // solium-disable-next-line security/no-block-members
+        uint256 elapsedTime = block.timestamp.sub(openingTime());
+        uint256 timeRange = closingTime().sub(openingTime());
+        uint256 rateRange = _initialRate.sub(_finalRate);
+        return _initialRate.sub(elapsedTime.mul(rateRange).div(timeRange));
+    }
+
+    /**
+     * @dev Overrides parent method taking into account variable rate.
+     * @param weiAmount The value in wei to be converted into tokens
+     * @return The number of tokens _weiAmount wei will buy at present time
+     */
+    function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
+        uint256 currentRate = getCurrentRate();
+        return currentRate.mul(weiAmount);
+    }
 }
diff --git a/contracts/crowdsale/validation/CappedCrowdsale.sol b/contracts/crowdsale/validation/CappedCrowdsale.sol
index 4d9eb604d..2b49362c2 100644
--- a/contracts/crowdsale/validation/CappedCrowdsale.sol
+++ b/contracts/crowdsale/validation/CappedCrowdsale.sol
@@ -8,48 +8,41 @@ import "../Crowdsale.sol";
  * @dev Crowdsale with a limit for total contributions.
  */
 contract CappedCrowdsale is Crowdsale {
-  using SafeMath for uint256;
+    using SafeMath for uint256;
 
-  uint256 private _cap;
+    uint256 private _cap;
 
-  /**
-   * @dev Constructor, takes maximum amount of wei accepted in the crowdsale.
-   * @param cap Max amount of wei to be contributed
-   */
-  constructor(uint256 cap) internal {
-    require(cap > 0);
-    _cap = cap;
-  }
+    /**
+     * @dev Constructor, takes maximum amount of wei accepted in the crowdsale.
+     * @param cap Max amount of wei to be contributed
+     */
+    constructor (uint256 cap) internal {
+        require(cap > 0);
+        _cap = cap;
+    }
 
-  /**
-   * @return the cap of the crowdsale.
-   */
-  function cap() public view returns(uint256) {
-    return _cap;
-  }
+    /**
+     * @return the cap of the crowdsale.
+     */
+    function cap() public view returns (uint256) {
+        return _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
-    view
-  {
-    super._preValidatePurchase(beneficiary, weiAmount);
-    require(weiRaised().add(weiAmount) <= _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 view {
+        super._preValidatePurchase(beneficiary, weiAmount);
+        require(weiRaised().add(weiAmount) <= _cap);
+    }
 }
diff --git a/contracts/crowdsale/validation/IndividuallyCappedCrowdsale.sol b/contracts/crowdsale/validation/IndividuallyCappedCrowdsale.sol
index 5a5d4e317..1bae0f96b 100644
--- a/contracts/crowdsale/validation/IndividuallyCappedCrowdsale.sol
+++ b/contracts/crowdsale/validation/IndividuallyCappedCrowdsale.sol
@@ -9,73 +9,57 @@ import "../../access/roles/CapperRole.sol";
  * @dev Crowdsale with per-beneficiary caps.
  */
 contract IndividuallyCappedCrowdsale is Crowdsale, CapperRole {
-  using SafeMath for uint256;
+    using SafeMath for uint256;
 
-  mapping(address => uint256) private _contributions;
-  mapping(address => uint256) private _caps;
+    mapping(address => uint256) private _contributions;
+    mapping(address => uint256) private _caps;
 
-  constructor() internal {}
+    constructor () internal {}
 
-  /**
-   * @dev Sets a specific beneficiary's maximum contribution.
-   * @param beneficiary Address to be capped
-   * @param cap Wei limit for individual contribution
-   */
-  function setCap(address beneficiary, uint256 cap) external onlyCapper {
-    _caps[beneficiary] = cap;
-  }
+    /**
+     * @dev Sets a specific beneficiary's maximum contribution.
+     * @param beneficiary Address to be capped
+     * @param cap Wei limit for individual contribution
+     */
+    function setCap(address beneficiary, uint256 cap) external onlyCapper {
+        _caps[beneficiary] = cap;
+    }
 
-  /**
-   * @dev Returns the cap of a specific beneficiary.
-   * @param beneficiary Address whose cap is to be checked
-   * @return Current cap for individual beneficiary
-   */
-  function getCap(address beneficiary) public view returns (uint256) {
-    return _caps[beneficiary];
-  }
+    /**
+     * @dev Returns the cap of a specific beneficiary.
+     * @param beneficiary Address whose cap is to be checked
+     * @return Current cap for individual beneficiary
+     */
+    function getCap(address beneficiary) public view returns (uint256) {
+        return _caps[beneficiary];
+    }
 
-  /**
-   * @dev Returns the amount contributed so far by a specific beneficiary.
-   * @param beneficiary Address of contributor
-   * @return Beneficiary contribution so far
-   */
-  function getContribution(address beneficiary)
-    public view returns (uint256)
-  {
-    return _contributions[beneficiary];
-  }
+    /**
+     * @dev Returns the amount contributed so far by a specific beneficiary.
+     * @param beneficiary Address of contributor
+     * @return Beneficiary contribution so far
+     */
+    function getContribution(address beneficiary) public view returns (uint256) {
+        return _contributions[beneficiary];
+    }
 
-  /**
-   * @dev Extend parent behavior requiring purchase to respect the beneficiary's funding cap.
-   * @param beneficiary Token purchaser
-   * @param weiAmount Amount of wei contributed
-   */
-  function _preValidatePurchase(
-    address beneficiary,
-    uint256 weiAmount
-  )
-    internal
-    view
-  {
-    super._preValidatePurchase(beneficiary, weiAmount);
-    require(
-      _contributions[beneficiary].add(weiAmount) <= _caps[beneficiary]);
-  }
-
-  /**
-   * @dev Extend parent behavior to update beneficiary 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);
-  }
+    /**
+     * @dev Extend parent behavior requiring purchase to respect the beneficiary's funding cap.
+     * @param beneficiary Token purchaser
+     * @param weiAmount Amount of wei contributed
+     */
+    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
+        super._preValidatePurchase(beneficiary, weiAmount);
+        require(_contributions[beneficiary].add(weiAmount) <= _caps[beneficiary]);
+    }
 
+    /**
+     * @dev Extend parent behavior to update beneficiary 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);
+    }
 }
diff --git a/contracts/crowdsale/validation/TimedCrowdsale.sol b/contracts/crowdsale/validation/TimedCrowdsale.sol
index 73d6a5c0f..244220034 100644
--- a/contracts/crowdsale/validation/TimedCrowdsale.sol
+++ b/contracts/crowdsale/validation/TimedCrowdsale.sol
@@ -8,78 +8,70 @@ import "../Crowdsale.sol";
  * @dev Crowdsale accepting contributions only within a time frame.
  */
 contract TimedCrowdsale is Crowdsale {
-  using SafeMath for uint256;
+    using SafeMath for uint256;
 
-  uint256 private _openingTime;
-  uint256 private _closingTime;
+    uint256 private _openingTime;
+    uint256 private _closingTime;
 
-  /**
-   * @dev Reverts if not in crowdsale time range.
-   */
-  modifier onlyWhileOpen {
-    require(isOpen());
-    _;
-  }
+    /**
+     * @dev Reverts if not in crowdsale time range.
+     */
+    modifier onlyWhileOpen {
+        require(isOpen());
+        _;
+    }
 
-  /**
-   * @dev Constructor, takes crowdsale opening and closing times.
-   * @param openingTime Crowdsale opening time
-   * @param closingTime Crowdsale closing time
-   */
-  constructor(uint256 openingTime, uint256 closingTime) internal {
-    // solium-disable-next-line security/no-block-members
-    require(openingTime >= block.timestamp);
-    require(closingTime > openingTime);
+    /**
+     * @dev Constructor, takes crowdsale opening and closing times.
+     * @param openingTime Crowdsale opening time
+     * @param closingTime Crowdsale closing time
+     */
+    constructor (uint256 openingTime, uint256 closingTime) internal {
+        // solium-disable-next-line security/no-block-members
+        require(openingTime >= block.timestamp);
+        require(closingTime > openingTime);
 
-    _openingTime = openingTime;
-    _closingTime = closingTime;
-  }
+        _openingTime = openingTime;
+        _closingTime = closingTime;
+    }
 
-  /**
-   * @return the crowdsale opening time.
-   */
-  function openingTime() public view returns(uint256) {
-    return _openingTime;
-  }
+    /**
+     * @return the crowdsale opening time.
+     */
+    function openingTime() public view returns (uint256) {
+        return _openingTime;
+    }
 
-  /**
-   * @return the crowdsale closing time.
-   */
-  function closingTime() public view returns(uint256) {
-    return _closingTime;
-  }
+    /**
+     * @return the crowdsale closing time.
+     */
+    function closingTime() public view returns (uint256) {
+        return _closingTime;
+    }
 
-  /**
-   * @return true if the crowdsale is open, false otherwise.
-   */
-  function isOpen() public view returns (bool) {
-    // solium-disable-next-line security/no-block-members
-    return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
-  }
+    /**
+     * @return true if the crowdsale is open, false otherwise.
+     */
+    function isOpen() public view returns (bool) {
+        // solium-disable-next-line security/no-block-members
+        return block.timestamp >= _openingTime && block.timestamp <= _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) {
-    // solium-disable-next-line security/no-block-members
-    return block.timestamp > _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
-    view
-  {
-    super._preValidatePurchase(beneficiary, weiAmount);
-  }
+    /**
+     * @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) {
+        // solium-disable-next-line security/no-block-members
+        return block.timestamp > _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 view {
+        super._preValidatePurchase(beneficiary, weiAmount);
+    }
 }
diff --git a/contracts/cryptography/ECDSA.sol b/contracts/cryptography/ECDSA.sol
index 71c0e41ed..4c91663ec 100644
--- a/contracts/cryptography/ECDSA.sol
+++ b/contracts/cryptography/ECDSA.sol
@@ -8,64 +8,53 @@ pragma solidity ^0.4.24;
  */
 
 library ECDSA {
+    /**
+     * @dev Recover signer address from a message by using their signature
+     * @param hash bytes32 message, the hash is the signed message. What is recovered is the signer address.
+     * @param signature bytes signature, the signature is generated using web3.eth.sign()
+     */
+    function recover(bytes32 hash, bytes signature) internal pure returns (address) {
+        bytes32 r;
+        bytes32 s;
+        uint8 v;
 
-  /**
-   * @dev Recover signer address from a message by using their signature
-   * @param hash bytes32 message, the hash is the signed message. What is recovered is the signer address.
-   * @param signature bytes signature, the signature is generated using web3.eth.sign()
-   */
-  function recover(bytes32 hash, bytes signature)
-    internal
-    pure
-    returns (address)
-  {
-    bytes32 r;
-    bytes32 s;
-    uint8 v;
+        // Check the signature length
+        if (signature.length != 65) {
+            return (address(0));
+        }
 
-    // Check the signature length
-    if (signature.length != 65) {
-      return (address(0));
+        // Divide the signature in r, s and v variables
+        // ecrecover takes the signature parameters, and the only way to get them
+        // currently is to use assembly.
+        // solium-disable-next-line security/no-inline-assembly
+        assembly {
+            r := mload(add(signature, 0x20))
+            s := mload(add(signature, 0x40))
+            v := byte(0, mload(add(signature, 0x60)))
+        }
+
+        // Version of signature should be 27 or 28, but 0 and 1 are also possible versions
+        if (v < 27) {
+            v += 27;
+        }
+
+        // If the version is correct return the signer address
+        if (v != 27 && v != 28) {
+            return (address(0));
+        } else {
+            // solium-disable-next-line arg-overflow
+            return ecrecover(hash, v, r, s);
+        }
     }
 
-    // Divide the signature in r, s and v variables
-    // ecrecover takes the signature parameters, and the only way to get them
-    // currently is to use assembly.
-    // solium-disable-next-line security/no-inline-assembly
-    assembly {
-      r := mload(add(signature, 0x20))
-      s := mload(add(signature, 0x40))
-      v := byte(0, mload(add(signature, 0x60)))
+    /**
+     * toEthSignedMessageHash
+     * @dev prefix a bytes32 value with "\x19Ethereum Signed Message:"
+     * and hash the result
+     */
+    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
+        // 32 is the length in bytes of hash,
+        // enforced by the type signature above
+        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
     }
-
-    // Version of signature should be 27 or 28, but 0 and 1 are also possible versions
-    if (v < 27) {
-      v += 27;
-    }
-
-    // If the version is correct return the signer address
-    if (v != 27 && v != 28) {
-      return (address(0));
-    } else {
-      // solium-disable-next-line arg-overflow
-      return ecrecover(hash, v, r, s);
-    }
-  }
-
-  /**
-   * toEthSignedMessageHash
-   * @dev prefix a bytes32 value with "\x19Ethereum Signed Message:"
-   * and hash the result
-   */
-  function toEthSignedMessageHash(bytes32 hash)
-    internal
-    pure
-    returns (bytes32)
-  {
-    // 32 is the length in bytes of hash,
-    // enforced by the type signature above
-    return keccak256(
-      abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)
-    );
-  }
 }
diff --git a/contracts/cryptography/MerkleProof.sol b/contracts/cryptography/MerkleProof.sol
index a0c304c57..31e469367 100644
--- a/contracts/cryptography/MerkleProof.sol
+++ b/contracts/cryptography/MerkleProof.sol
@@ -6,37 +6,29 @@ pragma solidity ^0.4.24;
  * https://github.com/ameensol/merkle-tree-solidity/blob/master/src/MerkleProof.sol
  */
 library MerkleProof {
-  /**
-   * @dev Verifies a Merkle proof proving the existence of a leaf in a Merkle tree. Assumes that each pair of leaves
-   * and each pair of pre-images are sorted.
-   * @param proof Merkle proof containing sibling hashes on the branch from the leaf to the root of the Merkle tree
-   * @param root Merkle root
-   * @param leaf Leaf of Merkle tree
-   */
-  function verify(
-    bytes32[] proof,
-    bytes32 root,
-    bytes32 leaf
-  )
-    internal
-    pure
-    returns (bool)
-  {
-    bytes32 computedHash = leaf;
+    /**
+     * @dev Verifies a Merkle proof proving the existence of a leaf in a Merkle tree. Assumes that each pair of leaves
+     * and each pair of pre-images are sorted.
+     * @param proof Merkle proof containing sibling hashes on the branch from the leaf to the root of the Merkle tree
+     * @param root Merkle root
+     * @param leaf Leaf of Merkle tree
+     */
+    function verify(bytes32[] proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
+        bytes32 computedHash = leaf;
 
-    for (uint256 i = 0; i < proof.length; i++) {
-      bytes32 proofElement = proof[i];
+        for (uint256 i = 0; i < proof.length; i++) {
+            bytes32 proofElement = proof[i];
 
-      if (computedHash < proofElement) {
-        // Hash(current computed hash + current element of the proof)
-        computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
-      } else {
-        // Hash(current element of the proof + current computed hash)
-        computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
-      }
+            if (computedHash < proofElement) {
+                // Hash(current computed hash + current element of the proof)
+                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
+            } else {
+                // Hash(current element of the proof + current computed hash)
+                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
+            }
+        }
+
+        // Check if the computed hash (root) is equal to the provided root
+        return computedHash == root;
     }
-
-    // Check if the computed hash (root) is equal to the provided root
-    return computedHash == root;
-  }
 }
diff --git a/contracts/drafts/Counter.sol b/contracts/drafts/Counter.sol
index 3557bd744..12bcf0848 100644
--- a/contracts/drafts/Counter.sol
+++ b/contracts/drafts/Counter.sol
@@ -13,16 +13,12 @@ pragma solidity ^0.4.24;
  * so it's not something you have to worry about.)
  */
 library Counter {
+    struct Counter {
+        uint256 current; // default: 0
+    }
 
-  struct Counter {
-    uint256 current; // default: 0
-  }
-
-  function next(Counter storage index)
-    internal
-    returns (uint256)
-  {
-    index.current += 1;
-    return index.current;
-  }
+    function next(Counter storage index) internal returns (uint256) {
+        index.current += 1;
+        return index.current;
+    }
 }
diff --git a/contracts/drafts/ERC1046/TokenMetadata.sol b/contracts/drafts/ERC1046/TokenMetadata.sol
index 9057711d9..460887221 100644
--- a/contracts/drafts/ERC1046/TokenMetadata.sol
+++ b/contracts/drafts/ERC1046/TokenMetadata.sol
@@ -9,19 +9,17 @@ import "../../token/ERC20/IERC20.sol";
  * @dev TODO - update https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/token/ERC721/IERC721.sol#L17 when 1046 is finalized
  */
 contract ERC20TokenMetadata is IERC20 {
-  function tokenURI() external view returns (string);
+    function tokenURI() external view returns (string);
 }
 
 contract ERC20WithMetadata is ERC20TokenMetadata {
-  string private _tokenURI;
+    string private _tokenURI;
 
-  constructor(string tokenURI)
-    public
-  {
-    _tokenURI = tokenURI;
-  }
+    constructor (string tokenURI) public {
+        _tokenURI = tokenURI;
+    }
 
-  function tokenURI() external view returns (string) {
-    return _tokenURI;
-  }
+    function tokenURI() external view returns (string) {
+        return _tokenURI;
+    }
 }
diff --git a/contracts/drafts/ERC20Migrator.sol b/contracts/drafts/ERC20Migrator.sol
index 44ed16423..83a0401ff 100644
--- a/contracts/drafts/ERC20Migrator.sol
+++ b/contracts/drafts/ERC20Migrator.sol
@@ -32,69 +32,69 @@ import "../math/Math.sol";
  * ```
  */
 contract ERC20Migrator {
-  using SafeERC20 for IERC20;
+    using SafeERC20 for IERC20;
 
-  /// Address of the old token contract
-  IERC20 private _legacyToken;
+    /// Address of the old token contract
+    IERC20 private _legacyToken;
 
-  /// Address of the new token contract
-  ERC20Mintable private _newToken;
+    /// Address of the new token contract
+    ERC20Mintable private _newToken;
 
-  /**
-   * @param legacyToken address of the old token contract
-   */
-  constructor(IERC20 legacyToken) public {
-    require(legacyToken != address(0));
-    _legacyToken = legacyToken;
-  }
+    /**
+     * @param legacyToken address of the old token contract
+     */
+    constructor (IERC20 legacyToken) public {
+        require(legacyToken != address(0));
+        _legacyToken = legacyToken;
+    }
 
-  /**
-   * @dev Returns the legacy token that is being migrated.
-   */
-  function legacyToken() public view returns (IERC20) {
-    return _legacyToken;
-  }
+    /**
+     * @dev Returns the legacy token that is being migrated.
+     */
+    function legacyToken() public view returns (IERC20) {
+        return _legacyToken;
+    }
 
-  /**
-   * @dev Returns the new token to which we are migrating.
-   */
-  function newToken() public view returns (IERC20) {
-    return _newToken;
-  }
+    /**
+     * @dev Returns the new token to which we are migrating.
+     */
+    function newToken() public view returns (IERC20) {
+        return _newToken;
+    }
 
-  /**
-   * @dev Begins the migration by setting which is the new token that will be
-   * minted. This contract must be a minter for the new token.
-   * @param newToken the token that will be minted
-   */
-  function beginMigration(ERC20Mintable newToken) public {
-    require(_newToken == address(0));
-    require(newToken != address(0));
-    require(newToken.isMinter(this));
+    /**
+     * @dev Begins the migration by setting which is the new token that will be
+     * minted. This contract must be a minter for the new token.
+     * @param newToken the token that will be minted
+     */
+    function beginMigration(ERC20Mintable newToken) public {
+        require(_newToken == address(0));
+        require(newToken != address(0));
+        require(newToken.isMinter(this));
 
-    _newToken = newToken;
-  }
+        _newToken = newToken;
+    }
 
-  /**
-   * @dev Transfers part of an account's balance in the old token to this
-   * contract, and mints the same amount of new tokens for that account.
-   * @param account whose tokens will be migrated
-   * @param amount amount of tokens to be migrated
-   */
-  function migrate(address account, uint256 amount) public {
-    _legacyToken.safeTransferFrom(account, this, amount);
-    _newToken.mint(account, amount);
-  }
+    /**
+     * @dev Transfers part of an account's balance in the old token to this
+     * contract, and mints the same amount of new tokens for that account.
+     * @param account whose tokens will be migrated
+     * @param amount amount of tokens to be migrated
+     */
+    function migrate(address account, uint256 amount) public {
+        _legacyToken.safeTransferFrom(account, this, amount);
+        _newToken.mint(account, amount);
+    }
 
-  /**
-   * @dev Transfers all of an account's allowed balance in the old token to
-   * this contract, and mints the same amount of new tokens for that account.
-   * @param account whose tokens will be migrated
-   */
-  function migrateAll(address account) public {
-    uint256 balance = _legacyToken.balanceOf(account);
-    uint256 allowance = _legacyToken.allowance(account, this);
-    uint256 amount = Math.min(balance, allowance);
-    migrate(account, amount);
-  }
+    /**
+     * @dev Transfers all of an account's allowed balance in the old token to
+     * this contract, and mints the same amount of new tokens for that account.
+     * @param account whose tokens will be migrated
+     */
+    function migrateAll(address account) public {
+        uint256 balance = _legacyToken.balanceOf(account);
+        uint256 allowance = _legacyToken.allowance(account, this);
+        uint256 amount = Math.min(balance, allowance);
+        migrate(account, amount);
+    }
 }
diff --git a/contracts/drafts/SignatureBouncer.sol b/contracts/drafts/SignatureBouncer.sol
index 2cd600b35..e0e33fcff 100644
--- a/contracts/drafts/SignatureBouncer.sol
+++ b/contracts/drafts/SignatureBouncer.sol
@@ -35,112 +35,84 @@ import "../cryptography/ECDSA.sol";
  * See https://ethereum.stackexchange.com/a/50616 for more details.
  */
 contract SignatureBouncer is SignerRole {
-  using ECDSA for bytes32;
+    using ECDSA for bytes32;
 
-  // Function selectors are 4 bytes long, as documented in
-  // https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector
-  uint256 private constant _METHOD_ID_SIZE = 4;
-  // Signature size is 65 bytes (tightly packed v + r + s), but gets padded to 96 bytes
-  uint256 private constant _SIGNATURE_SIZE = 96;
+    // Function selectors are 4 bytes long, as documented in
+    // https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector
+    uint256 private constant _METHOD_ID_SIZE = 4;
+    // Signature size is 65 bytes (tightly packed v + r + s), but gets padded to 96 bytes
+    uint256 private constant _SIGNATURE_SIZE = 96;
 
-  constructor() internal {}
+    constructor () internal {}
 
-  /**
-   * @dev requires that a valid signature of a signer was provided
-   */
-  modifier onlyValidSignature(bytes signature)
-  {
-    require(_isValidSignature(msg.sender, signature));
-    _;
-  }
-
-  /**
-   * @dev requires that a valid signature with a specifed method of a signer was provided
-   */
-  modifier onlyValidSignatureAndMethod(bytes signature)
-  {
-    require(_isValidSignatureAndMethod(msg.sender, signature));
-    _;
-  }
-
-  /**
-   * @dev requires that a valid signature with a specifed method and params of a signer was provided
-   */
-  modifier onlyValidSignatureAndData(bytes signature)
-  {
-    require(_isValidSignatureAndData(msg.sender, signature));
-    _;
-  }
-
-  /**
-   * @dev is the signature of `this + sender` from a signer?
-   * @return bool
-   */
-  function _isValidSignature(address account, bytes signature)
-    internal
-    view
-    returns (bool)
-  {
-    return _isValidDataHash(
-      keccak256(abi.encodePacked(address(this), account)),
-      signature
-    );
-  }
-
-  /**
-   * @dev is the signature of `this + sender + methodId` from a signer?
-   * @return bool
-   */
-  function _isValidSignatureAndMethod(address account, bytes signature)
-    internal
-    view
-    returns (bool)
-  {
-    bytes memory data = new bytes(_METHOD_ID_SIZE);
-    for (uint i = 0; i < data.length; i++) {
-      data[i] = msg.data[i];
+    /**
+     * @dev requires that a valid signature of a signer was provided
+     */
+    modifier onlyValidSignature(bytes signature) {
+        require(_isValidSignature(msg.sender, signature));
+        _;
     }
-    return _isValidDataHash(
-      keccak256(abi.encodePacked(address(this), account, data)),
-      signature
-    );
-  }
 
-  /**
-    * @dev is the signature of `this + sender + methodId + params(s)` from a signer?
-    * @notice the signature parameter of the method being validated must be the "last" parameter
-    * @return bool
-    */
-  function _isValidSignatureAndData(address account, bytes signature)
-    internal
-    view
-    returns (bool)
-  {
-    require(msg.data.length > _SIGNATURE_SIZE);
-    bytes memory data = new bytes(msg.data.length - _SIGNATURE_SIZE);
-    for (uint i = 0; i < data.length; i++) {
-      data[i] = msg.data[i];
+    /**
+     * @dev requires that a valid signature with a specifed method of a signer was provided
+     */
+    modifier onlyValidSignatureAndMethod(bytes signature) {
+        require(_isValidSignatureAndMethod(msg.sender, signature));
+        _;
     }
-    return _isValidDataHash(
-      keccak256(abi.encodePacked(address(this), account, data)),
-      signature
-    );
-  }
 
-  /**
-   * @dev internal function to convert a hash to an eth signed message
-   * and then recover the signature and check it against the signer role
-   * @return bool
-   */
-  function _isValidDataHash(bytes32 hash, bytes signature)
-    internal
-    view
-    returns (bool)
-  {
-    address signer = hash
-      .toEthSignedMessageHash()
-      .recover(signature);
+    /**
+     * @dev requires that a valid signature with a specifed method and params of a signer was provided
+     */
+    modifier onlyValidSignatureAndData(bytes signature) {
+        require(_isValidSignatureAndData(msg.sender, signature));
+        _;
+    }
 
-    return signer != address(0) && isSigner(signer);
-  }
+    /**
+     * @dev is the signature of `this + sender` from a signer?
+     * @return bool
+     */
+    function _isValidSignature(address account, bytes signature) internal view returns (bool) {
+        return _isValidDataHash(keccak256(abi.encodePacked(address(this), account)), signature);
+    }
+
+    /**
+     * @dev is the signature of `this + sender + methodId` from a signer?
+     * @return bool
+     */
+    function _isValidSignatureAndMethod(address account, bytes signature) internal view returns (bool) {
+        bytes memory data = new bytes(_METHOD_ID_SIZE);
+        for (uint i = 0; i < data.length; i++) {
+            data[i] = msg.data[i];
+        }
+        return _isValidDataHash(keccak256(abi.encodePacked(address(this), account, data)), signature);
+    }
+
+    /**
+        * @dev is the signature of `this + sender + methodId + params(s)` from a signer?
+        * @notice the signature parameter of the method being validated must be the "last" parameter
+        * @return bool
+        */
+    function _isValidSignatureAndData(address account, bytes signature) internal view returns (bool) {
+        require(msg.data.length > _SIGNATURE_SIZE);
+
+        bytes memory data = new bytes(msg.data.length - _SIGNATURE_SIZE);
+        for (uint i = 0; i < data.length; i++) {
+            data[i] = msg.data[i];
+        }
+
+        return _isValidDataHash(keccak256(abi.encodePacked(address(this), account, data)), signature);
+    }
+
+    /**
+     * @dev internal function to convert a hash to an eth signed message
+     * and then recover the signature and check it against the signer role
+     * @return bool
+     */
+    function _isValidDataHash(bytes32 hash, bytes signature) internal view returns (bool) {
+        address signer = hash.toEthSignedMessageHash().recover(signature);
+
+        return signer != address(0) && isSigner(signer);
+    }
 }
diff --git a/contracts/drafts/TokenVesting.sol b/contracts/drafts/TokenVesting.sol
index 3fa49f79f..d8ea749e1 100644
--- a/contracts/drafts/TokenVesting.sol
+++ b/contracts/drafts/TokenVesting.sol
@@ -13,163 +13,155 @@ import "../math/SafeMath.sol";
  * owner.
  */
 contract TokenVesting is Ownable {
-  using SafeMath for uint256;
-  using SafeERC20 for IERC20;
+    using SafeMath for uint256;
+    using SafeERC20 for IERC20;
 
-  event TokensReleased(address token, uint256 amount);
-  event TokenVestingRevoked(address token);
+    event TokensReleased(address token, uint256 amount);
+    event TokenVestingRevoked(address token);
 
-  // beneficiary of tokens after they are released
-  address private _beneficiary;
+    // beneficiary of tokens after they are released
+    address private _beneficiary;
 
-  uint256 private _cliff;
-  uint256 private _start;
-  uint256 private _duration;
+    uint256 private _cliff;
+    uint256 private _start;
+    uint256 private _duration;
 
-  bool private _revocable;
+    bool private _revocable;
 
-  mapping (address => uint256) private _released;
-  mapping (address => bool) private _revoked;
+    mapping (address => uint256) private _released;
+    mapping (address => bool) private _revoked;
 
-  /**
-   * @dev Creates a vesting contract that vests its balance of any ERC20 token to the
-   * beneficiary, gradually in a linear fashion until start + duration. By then all
-   * of the balance will have vested.
-   * @param beneficiary address of the beneficiary to whom vested tokens are transferred
-   * @param cliffDuration duration in seconds of the cliff in which tokens will begin to vest
-   * @param start the time (as Unix time) at which point vesting starts
-   * @param duration duration in seconds of the period in which the tokens will vest
-   * @param revocable whether the vesting is revocable or not
-   */
-  constructor(
-    address beneficiary,
-    uint256 start,
-    uint256 cliffDuration,
-    uint256 duration,
-    bool revocable
-  )
-    public
-  {
-    require(beneficiary != address(0));
-    require(cliffDuration <= duration);
-    require(duration > 0);
-    require(start.add(duration) > block.timestamp);
+    /**
+     * @dev Creates a vesting contract that vests its balance of any ERC20 token to the
+     * beneficiary, gradually in a linear fashion until start + duration. By then all
+     * of the balance will have vested.
+     * @param beneficiary address of the beneficiary to whom vested tokens are transferred
+     * @param cliffDuration duration in seconds of the cliff in which tokens will begin to vest
+     * @param start the time (as Unix time) at which point vesting starts
+     * @param duration duration in seconds of the period in which the tokens will vest
+     * @param revocable whether the vesting is revocable or not
+     */
+    constructor (address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, bool revocable) public {
+        require(beneficiary != address(0));
+        require(cliffDuration <= duration);
+        require(duration > 0);
+        require(start.add(duration) > block.timestamp);
 
-    _beneficiary = beneficiary;
-    _revocable = revocable;
-    _duration = duration;
-    _cliff = start.add(cliffDuration);
-    _start = start;
-  }
-
-  /**
-   * @return the beneficiary of the tokens.
-   */
-  function beneficiary() public view returns(address) {
-    return _beneficiary;
-  }
-
-  /**
-   * @return the cliff time of the token vesting.
-   */
-  function cliff() public view returns(uint256) {
-    return _cliff;
-  }
-
-  /**
-   * @return the start time of the token vesting.
-   */
-  function start() public view returns(uint256) {
-    return _start;
-  }
-
-  /**
-   * @return the duration of the token vesting.
-   */
-  function duration() public view returns(uint256) {
-    return _duration;
-  }
-
-  /**
-   * @return true if the vesting is revocable.
-   */
-  function revocable() public view returns(bool) {
-    return _revocable;
-  }
-
-  /**
-   * @return the amount of the token released.
-   */
-  function released(address token) public view returns(uint256) {
-    return _released[token];
-  }
-
-  /**
-   * @return true if the token is revoked.
-   */
-  function revoked(address token) public view returns(bool) {
-    return _revoked[token];
-  }
-
-  /**
-   * @notice Transfers vested tokens to beneficiary.
-   * @param token ERC20 token which is being vested
-   */
-  function release(IERC20 token) public {
-    uint256 unreleased = _releasableAmount(token);
-
-    require(unreleased > 0);
-
-    _released[token] = _released[token].add(unreleased);
-
-    token.safeTransfer(_beneficiary, unreleased);
-
-    emit TokensReleased(token, unreleased);
-  }
-
-  /**
-   * @notice Allows the owner to revoke the vesting. Tokens already vested
-   * remain in the contract, the rest are returned to the owner.
-   * @param token ERC20 token which is being vested
-   */
-  function revoke(IERC20 token) public onlyOwner {
-    require(_revocable);
-    require(!_revoked[token]);
-
-    uint256 balance = token.balanceOf(address(this));
-
-    uint256 unreleased = _releasableAmount(token);
-    uint256 refund = balance.sub(unreleased);
-
-    _revoked[token] = true;
-
-    token.safeTransfer(owner(), refund);
-
-    emit TokenVestingRevoked(token);
-  }
-
-  /**
-   * @dev Calculates the amount that has already vested but hasn't been released yet.
-   * @param token ERC20 token which is being vested
-   */
-  function _releasableAmount(IERC20 token) private view returns (uint256) {
-    return _vestedAmount(token).sub(_released[token]);
-  }
-
-  /**
-   * @dev Calculates the amount that has already vested.
-   * @param token ERC20 token which is being vested
-   */
-  function _vestedAmount(IERC20 token) private view returns (uint256) {
-    uint256 currentBalance = token.balanceOf(address(this));
-    uint256 totalBalance = currentBalance.add(_released[token]);
-
-    if (block.timestamp < _cliff) {
-      return 0;
-    } else if (block.timestamp >= _start.add(_duration) || _revoked[token]) {
-      return totalBalance;
-    } else {
-      return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);
+        _beneficiary = beneficiary;
+        _revocable = revocable;
+        _duration = duration;
+        _cliff = start.add(cliffDuration);
+        _start = start;
+    }
+
+    /**
+     * @return the beneficiary of the tokens.
+     */
+    function beneficiary() public view returns (address) {
+        return _beneficiary;
+    }
+
+    /**
+     * @return the cliff time of the token vesting.
+     */
+    function cliff() public view returns (uint256) {
+        return _cliff;
+    }
+
+    /**
+     * @return the start time of the token vesting.
+     */
+    function start() public view returns (uint256) {
+        return _start;
+    }
+
+    /**
+     * @return the duration of the token vesting.
+     */
+    function duration() public view returns (uint256) {
+        return _duration;
+    }
+
+    /**
+     * @return true if the vesting is revocable.
+     */
+    function revocable() public view returns (bool) {
+        return _revocable;
+    }
+
+    /**
+     * @return the amount of the token released.
+     */
+    function released(address token) public view returns (uint256) {
+        return _released[token];
+    }
+
+    /**
+     * @return true if the token is revoked.
+     */
+    function revoked(address token) public view returns (bool) {
+        return _revoked[token];
+    }
+
+    /**
+     * @notice Transfers vested tokens to beneficiary.
+     * @param token ERC20 token which is being vested
+     */
+    function release(IERC20 token) public {
+        uint256 unreleased = _releasableAmount(token);
+
+        require(unreleased > 0);
+
+        _released[token] = _released[token].add(unreleased);
+
+        token.safeTransfer(_beneficiary, unreleased);
+
+        emit TokensReleased(token, unreleased);
+    }
+
+    /**
+     * @notice Allows the owner to revoke the vesting. Tokens already vested
+     * remain in the contract, the rest are returned to the owner.
+     * @param token ERC20 token which is being vested
+     */
+    function revoke(IERC20 token) public onlyOwner {
+        require(_revocable);
+        require(!_revoked[token]);
+
+        uint256 balance = token.balanceOf(address(this));
+
+        uint256 unreleased = _releasableAmount(token);
+        uint256 refund = balance.sub(unreleased);
+
+        _revoked[token] = true;
+
+        token.safeTransfer(owner(), refund);
+
+        emit TokenVestingRevoked(token);
+    }
+
+    /**
+     * @dev Calculates the amount that has already vested but hasn't been released yet.
+     * @param token ERC20 token which is being vested
+     */
+    function _releasableAmount(IERC20 token) private view returns (uint256) {
+        return _vestedAmount(token).sub(_released[token]);
+    }
+
+    /**
+     * @dev Calculates the amount that has already vested.
+     * @param token ERC20 token which is being vested
+     */
+    function _vestedAmount(IERC20 token) private view returns (uint256) {
+        uint256 currentBalance = token.balanceOf(address(this));
+        uint256 totalBalance = currentBalance.add(_released[token]);
+
+        if (block.timestamp < _cliff) {
+            return 0;
+        } else if (block.timestamp >= _start.add(_duration) || _revoked[token]) {
+            return totalBalance;
+        } else {
+            return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);
+        }
     }
-  }
 }
diff --git a/contracts/examples/SampleCrowdsale.sol b/contracts/examples/SampleCrowdsale.sol
index d22598092..45bf24b11 100644
--- a/contracts/examples/SampleCrowdsale.sol
+++ b/contracts/examples/SampleCrowdsale.sol
@@ -12,7 +12,7 @@ import "../token/ERC20/ERC20Detailed.sol";
  * It is meant to be used in a crowdsale contract.
  */
 contract SampleCrowdsaleToken is ERC20Mintable, ERC20Detailed {
-  constructor() public ERC20Detailed("Sample Crowdsale Token", "SCT", 18) {}
+    constructor () public ERC20Detailed("Sample Crowdsale Token", "SCT", 18) {}
 }
 
 /**
@@ -34,24 +34,23 @@ contract SampleCrowdsaleToken is ERC20Mintable, ERC20Detailed {
 // --elopio - 2018-05-10
 // solium-disable-next-line max-len
 contract SampleCrowdsale is CappedCrowdsale, RefundableCrowdsale, MintedCrowdsale {
-
-  constructor(
-    uint256 openingTime,
-    uint256 closingTime,
-    uint256 rate,
-    address wallet,
-    uint256 cap,
-    ERC20Mintable token,
-    uint256 goal
-  )
-    public
-    Crowdsale(rate, wallet, token)
-    CappedCrowdsale(cap)
-    TimedCrowdsale(openingTime, closingTime)
-    RefundableCrowdsale(goal)
-  {
-    //As goal needs to be met for a successful crowdsale
-    //the value needs to less or equal than a cap which is limit for accepted funds
-    require(goal <= cap);
-  }
+    constructor (
+        uint256 openingTime,
+        uint256 closingTime,
+        uint256 rate,
+        address wallet,
+        uint256 cap,
+        ERC20Mintable token,
+        uint256 goal
+    )
+        public
+        Crowdsale(rate, wallet, token)
+        CappedCrowdsale(cap)
+        TimedCrowdsale(openingTime, closingTime)
+        RefundableCrowdsale(goal)
+    {
+        //As goal needs to be met for a successful crowdsale
+        //the value needs to less or equal than a cap which is limit for accepted funds
+        require(goal <= cap);
+    }
 }
diff --git a/contracts/examples/SimpleToken.sol b/contracts/examples/SimpleToken.sol
index 04b016a73..95b31ea37 100644
--- a/contracts/examples/SimpleToken.sol
+++ b/contracts/examples/SimpleToken.sol
@@ -10,14 +10,12 @@ import "../token/ERC20/ERC20Detailed.sol";
  * `ERC20` functions.
  */
 contract SimpleToken is ERC20, ERC20Detailed {
+    uint256 public constant INITIAL_SUPPLY = 10000 * (10 ** uint256(decimals()));
 
-  uint256 public constant INITIAL_SUPPLY = 10000 * (10 ** uint256(decimals()));
-
-  /**
-   * @dev Constructor that gives msg.sender all of existing tokens.
-   */
-  constructor() public ERC20Detailed("SimpleToken", "SIM", 18) {
-    _mint(msg.sender, INITIAL_SUPPLY);
-  }
-
+    /**
+     * @dev Constructor that gives msg.sender all of existing tokens.
+     */
+    constructor () public ERC20Detailed("SimpleToken", "SIM", 18) {
+        _mint(msg.sender, INITIAL_SUPPLY);
+    }
 }
diff --git a/contracts/introspection/ERC165.sol b/contracts/introspection/ERC165.sol
index 5d083acdf..f1dfbcff1 100644
--- a/contracts/introspection/ERC165.sol
+++ b/contracts/introspection/ERC165.sol
@@ -8,46 +8,37 @@ import "./IERC165.sol";
  * @dev Implements ERC165 using a lookup table.
  */
 contract ERC165 is IERC165 {
+    bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
+    /**
+     * 0x01ffc9a7 ===
+     *     bytes4(keccak256('supportsInterface(bytes4)'))
+     */
 
-  bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
-  /**
-   * 0x01ffc9a7 ===
-   *   bytes4(keccak256('supportsInterface(bytes4)'))
-   */
+    /**
+     * @dev a mapping of interface id to whether or not it's supported
+     */
+    mapping(bytes4 => bool) private _supportedInterfaces;
 
-  /**
-   * @dev a mapping of interface id to whether or not it's supported
-   */
-  mapping(bytes4 => bool) private _supportedInterfaces;
+    /**
+     * @dev A contract implementing SupportsInterfaceWithLookup
+     * implement ERC165 itself
+     */
+    constructor () internal {
+        _registerInterface(_InterfaceId_ERC165);
+    }
 
-  /**
-   * @dev A contract implementing SupportsInterfaceWithLookup
-   * implement ERC165 itself
-   */
-  constructor()
-    internal
-  {
-    _registerInterface(_InterfaceId_ERC165);
-  }
+    /**
+     * @dev implement supportsInterface(bytes4) using a lookup table
+     */
+    function supportsInterface(bytes4 interfaceId) external view returns (bool) {
+        return _supportedInterfaces[interfaceId];
+    }
 
-  /**
-   * @dev implement supportsInterface(bytes4) using a lookup table
-   */
-  function supportsInterface(bytes4 interfaceId)
-    external
-    view
-    returns (bool)
-  {
-    return _supportedInterfaces[interfaceId];
-  }
-
-  /**
-   * @dev internal method for registering an interface
-   */
-  function _registerInterface(bytes4 interfaceId)
-    internal
-  {
-    require(interfaceId != 0xffffffff);
-    _supportedInterfaces[interfaceId] = true;
-  }
+    /**
+     * @dev internal method for registering an interface
+     */
+    function _registerInterface(bytes4 interfaceId) internal {
+        require(interfaceId != 0xffffffff);
+        _supportedInterfaces[interfaceId] = true;
+    }
 }
diff --git a/contracts/introspection/ERC165Checker.sol b/contracts/introspection/ERC165Checker.sol
index 2490b191e..e40db319e 100644
--- a/contracts/introspection/ERC165Checker.sol
+++ b/contracts/introspection/ERC165Checker.sol
@@ -6,141 +6,118 @@ pragma solidity ^0.4.24;
  * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
  */
 library ERC165Checker {
-  // As per the EIP-165 spec, no interface should ever match 0xffffffff
-  bytes4 private constant _InterfaceId_Invalid = 0xffffffff;
+    // As per the EIP-165 spec, no interface should ever match 0xffffffff
+    bytes4 private constant _InterfaceId_Invalid = 0xffffffff;
 
-  bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
-  /**
-   * 0x01ffc9a7 ===
-   *   bytes4(keccak256('supportsInterface(bytes4)'))
-   */
+    bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
+    /**
+     * 0x01ffc9a7 ===
+     *     bytes4(keccak256('supportsInterface(bytes4)'))
+     */
 
-  /**
-   * @notice Query if a contract supports ERC165
-   * @param account The address of the contract to query for support of ERC165
-   * @return true if the contract at account implements ERC165
-   */
-  function _supportsERC165(address account)
-    internal
-    view
-    returns (bool)
-  {
-    // Any contract that implements ERC165 must explicitly indicate support of
-    // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
-    return _supportsERC165Interface(account, _InterfaceId_ERC165) &&
-      !_supportsERC165Interface(account, _InterfaceId_Invalid);
-  }
-
-  /**
-   * @notice Query if a contract implements an interface, also checks support of ERC165
-   * @param account The address of the contract to query for support of an interface
-   * @param interfaceId The interface identifier, as specified in ERC-165
-   * @return true if the contract at account indicates support of the interface with
-   * identifier interfaceId, false otherwise
-   * @dev Interface identification is specified in ERC-165.
-   */
-  function _supportsInterface(address account, bytes4 interfaceId)
-    internal
-    view
-    returns (bool)
-  {
-    // query support of both ERC165 as per the spec and support of _interfaceId
-    return _supportsERC165(account) &&
-      _supportsERC165Interface(account, interfaceId);
-  }
-
-  /**
-   * @notice Query if a contract implements interfaces, also checks support of ERC165
-   * @param account The address of the contract to query for support of an interface
-   * @param interfaceIds A list of interface identifiers, as specified in ERC-165
-   * @return true if the contract at account indicates support all interfaces in the
-   * interfaceIds list, false otherwise
-   * @dev Interface identification is specified in ERC-165.
-   */
-  function _supportsAllInterfaces(address account, bytes4[] interfaceIds)
-    internal
-    view
-    returns (bool)
-  {
-    // query support of ERC165 itself
-    if (!_supportsERC165(account)) {
-      return false;
+    /**
+     * @notice Query if a contract supports ERC165
+     * @param account The address of the contract to query for support of ERC165
+     * @return true if the contract at account implements ERC165
+     */
+    function _supportsERC165(address account) internal view returns (bool) {
+        // Any contract that implements ERC165 must explicitly indicate support of
+        // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
+        return _supportsERC165Interface(account, _InterfaceId_ERC165) &&
+            !_supportsERC165Interface(account, _InterfaceId_Invalid);
     }
 
-    // query support of each interface in _interfaceIds
-    for (uint256 i = 0; i < interfaceIds.length; i++) {
-      if (!_supportsERC165Interface(account, interfaceIds[i])) {
-        return false;
-      }
+    /**
+     * @notice Query if a contract implements an interface, also checks support of ERC165
+     * @param account The address of the contract to query for support of an interface
+     * @param interfaceId The interface identifier, as specified in ERC-165
+     * @return true if the contract at account indicates support of the interface with
+     * identifier interfaceId, false otherwise
+     * @dev Interface identification is specified in ERC-165.
+     */
+    function _supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
+        // query support of both ERC165 as per the spec and support of _interfaceId
+        return _supportsERC165(account) &&
+            _supportsERC165Interface(account, interfaceId);
     }
 
-    // all interfaces supported
-    return true;
-  }
+    /**
+     * @notice Query if a contract implements interfaces, also checks support of ERC165
+     * @param account The address of the contract to query for support of an interface
+     * @param interfaceIds A list of interface identifiers, as specified in ERC-165
+     * @return true if the contract at account indicates support all interfaces in the
+     * interfaceIds list, false otherwise
+     * @dev Interface identification is specified in ERC-165.
+     */
+    function _supportsAllInterfaces(address account, bytes4[] interfaceIds) internal view returns (bool) {
+        // query support of ERC165 itself
+        if (!_supportsERC165(account)) {
+            return false;
+        }
 
-  /**
-   * @notice Query if a contract implements an interface, does not check ERC165 support
-   * @param account The address of the contract to query for support of an interface
-   * @param interfaceId The interface identifier, as specified in ERC-165
-   * @return true if the contract at account indicates support of the interface with
-   * identifier interfaceId, false otherwise
-   * @dev Assumes that account contains a contract that supports ERC165, otherwise
-   * the behavior of this method is undefined. This precondition can be checked
-   * with the `supportsERC165` method in this library.
-   * Interface identification is specified in ERC-165.
-   */
-  function _supportsERC165Interface(address account, bytes4 interfaceId)
-    private
-    view
-    returns (bool)
-  {
-    // success determines whether the staticcall succeeded and result determines
-    // whether the contract at account indicates support of _interfaceId
-    (bool success, bool result) = _callERC165SupportsInterface(
-      account, interfaceId);
+        // query support of each interface in _interfaceIds
+        for (uint256 i = 0; i < interfaceIds.length; i++) {
+            if (!_supportsERC165Interface(account, interfaceIds[i])) {
+                return false;
+            }
+        }
 
-    return (success && result);
-  }
-
-  /**
-   * @notice Calls the function with selector 0x01ffc9a7 (ERC165) and suppresses throw
-   * @param account The address of the contract to query for support of an interface
-   * @param interfaceId The interface identifier, as specified in ERC-165
-   * @return success true if the STATICCALL succeeded, false otherwise
-   * @return result true if the STATICCALL succeeded and the contract at account
-   * indicates support of the interface with identifier interfaceId, false otherwise
-   */
-  function _callERC165SupportsInterface(
-    address account,
-    bytes4 interfaceId
-  )
-    private
-    view
-    returns (bool success, bool result)
-  {
-    bytes memory encodedParams = abi.encodeWithSelector(
-      _InterfaceId_ERC165,
-      interfaceId
-    );
-
-    // solium-disable-next-line security/no-inline-assembly
-    assembly {
-      let encodedParams_data := add(0x20, encodedParams)
-      let encodedParams_size := mload(encodedParams)
-
-      let output := mload(0x40)  // Find empty storage location using "free memory pointer"
-      mstore(output, 0x0)
-
-      success := staticcall(
-        30000,                 // 30k gas
-        account,              // To addr
-        encodedParams_data,
-        encodedParams_size,
-        output,
-        0x20                   // Outputs are 32 bytes long
-      )
-
-      result := mload(output)  // Load the result
+        // all interfaces supported
+        return true;
+    }
+
+    /**
+     * @notice Query if a contract implements an interface, does not check ERC165 support
+     * @param account The address of the contract to query for support of an interface
+     * @param interfaceId The interface identifier, as specified in ERC-165
+     * @return true if the contract at account indicates support of the interface with
+     * identifier interfaceId, false otherwise
+     * @dev Assumes that account contains a contract that supports ERC165, otherwise
+     * the behavior of this method is undefined. This precondition can be checked
+     * with the `supportsERC165` method in this library.
+     * Interface identification is specified in ERC-165.
+     */
+    function _supportsERC165Interface(address account, bytes4 interfaceId) private view returns (bool) {
+        // success determines whether the staticcall succeeded and result determines
+        // whether the contract at account indicates support of _interfaceId
+        (bool success, bool result) = _callERC165SupportsInterface(account, interfaceId);
+
+        return (success && result);
+    }
+
+    /**
+     * @notice Calls the function with selector 0x01ffc9a7 (ERC165) and suppresses throw
+     * @param account The address of the contract to query for support of an interface
+     * @param interfaceId The interface identifier, as specified in ERC-165
+     * @return success true if the STATICCALL succeeded, false otherwise
+     * @return result true if the STATICCALL succeeded and the contract at account
+     * indicates support of the interface with identifier interfaceId, false otherwise
+     */
+    function _callERC165SupportsInterface(address account, bytes4 interfaceId)
+      private
+      view
+      returns (bool success, bool result)
+    {
+        bytes memory encodedParams = abi.encodeWithSelector(_InterfaceId_ERC165,interfaceId);
+
+        // solium-disable-next-line security/no-inline-assembly
+        assembly {
+            let encodedParams_data := add(0x20, encodedParams)
+            let encodedParams_size := mload(encodedParams)
+
+            let output := mload(0x40)    // Find empty storage location using "free memory pointer"
+            mstore(output, 0x0)
+
+            success := staticcall(
+                30000,                                 // 30k gas
+                account,                            // To addr
+                encodedParams_data,
+                encodedParams_size,
+                output,
+                0x20                                     // Outputs are 32 bytes long
+            )
+
+            result := mload(output)    // Load the result
+        }
     }
-  }
 }
diff --git a/contracts/introspection/IERC165.sol b/contracts/introspection/IERC165.sol
index 4e4b7bbf6..da133b0b4 100644
--- a/contracts/introspection/IERC165.sol
+++ b/contracts/introspection/IERC165.sol
@@ -5,15 +5,11 @@ pragma solidity ^0.4.24;
  * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
  */
 interface IERC165 {
-
-  /**
-   * @notice Query if a contract implements an interface
-   * @param interfaceId The interface identifier, as specified in ERC-165
-   * @dev Interface identification is specified in ERC-165. This function
-   * uses less than 30,000 gas.
-   */
-  function supportsInterface(bytes4 interfaceId)
-    external
-    view
-    returns (bool);
+    /**
+     * @notice Query if a contract implements an interface
+     * @param interfaceId The interface identifier, as specified in ERC-165
+     * @dev Interface identification is specified in ERC-165. This function
+     * uses less than 30,000 gas.
+     */
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
 }
diff --git a/contracts/lifecycle/Pausable.sol b/contracts/lifecycle/Pausable.sol
index 3703fed4b..d74759440 100644
--- a/contracts/lifecycle/Pausable.sol
+++ b/contracts/lifecycle/Pausable.sol
@@ -7,51 +7,51 @@ import "../access/roles/PauserRole.sol";
  * @dev Base contract which allows children to implement an emergency stop mechanism.
  */
 contract Pausable is PauserRole {
-  event Paused(address account);
-  event Unpaused(address account);
+    event Paused(address account);
+    event Unpaused(address account);
 
-  bool private _paused;
+    bool private _paused;
 
-  constructor() internal {
-    _paused = false;
-  }
+    constructor () internal {
+        _paused = false;
+    }
 
-  /**
-   * @return true if the contract is paused, false otherwise.
-   */
-  function paused() public view returns(bool) {
-    return _paused;
-  }
+    /**
+     * @return true if the contract is paused, false otherwise.
+     */
+    function paused() public view returns (bool) {
+        return _paused;
+    }
 
-  /**
-   * @dev Modifier to make a function callable only when the contract is not paused.
-   */
-  modifier whenNotPaused() {
-    require(!_paused);
-    _;
-  }
+    /**
+     * @dev Modifier to make a function callable only when the contract is not paused.
+     */
+    modifier whenNotPaused() {
+        require(!_paused);
+        _;
+    }
 
-  /**
-   * @dev Modifier to make a function callable only when the contract is paused.
-   */
-  modifier whenPaused() {
-    require(_paused);
-    _;
-  }
+    /**
+     * @dev Modifier to make a function callable only when the contract is paused.
+     */
+    modifier whenPaused() {
+        require(_paused);
+        _;
+    }
 
-  /**
-   * @dev called by the owner to pause, triggers stopped state
-   */
-  function pause() public onlyPauser whenNotPaused {
-    _paused = true;
-    emit Paused(msg.sender);
-  }
+    /**
+     * @dev called by the owner to pause, triggers stopped state
+     */
+    function pause() public onlyPauser whenNotPaused {
+        _paused = true;
+        emit Paused(msg.sender);
+    }
 
-  /**
-   * @dev called by the owner to unpause, returns to normal state
-   */
-  function unpause() public onlyPauser whenPaused {
-    _paused = false;
-    emit Unpaused(msg.sender);
-  }
+    /**
+     * @dev called by the owner to unpause, returns to normal state
+     */
+    function unpause() public onlyPauser whenPaused {
+        _paused = false;
+        emit Unpaused(msg.sender);
+    }
 }
diff --git a/contracts/math/Math.sol b/contracts/math/Math.sol
index ffff83961..b57f0d3e6 100644
--- a/contracts/math/Math.sol
+++ b/contracts/math/Math.sol
@@ -5,27 +5,27 @@ pragma solidity ^0.4.24;
  * @dev Assorted math operations
  */
 library Math {
-  /**
-  * @dev Returns the largest of two numbers.
-  */
-  function max(uint256 a, uint256 b) internal pure returns (uint256) {
-    return a >= b ? a : b;
-  }
+    /**
+    * @dev Returns the largest of two numbers.
+    */
+    function max(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a >= b ? a : b;
+    }
 
-  /**
-  * @dev Returns the smallest of two numbers.
-  */
-  function min(uint256 a, uint256 b) internal pure returns (uint256) {
-    return a < b ? a : b;
-  }
+    /**
+    * @dev Returns the smallest of two numbers.
+    */
+    function min(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a < b ? a : b;
+    }
 
-  /**
-  * @dev Calculates the average of two numbers. Since these are integers,
-  * averages of an even and odd number cannot be represented, and will be
-  * rounded down.
-  */
-  function average(uint256 a, uint256 b) internal pure returns (uint256) {
-    // (a + b) / 2 can overflow, so we distribute
-    return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
-  }
+    /**
+    * @dev Calculates the average of two numbers. Since these are integers,
+    * averages of an even and odd number cannot be represented, and will be
+    * rounded down.
+    */
+    function average(uint256 a, uint256 b) internal pure returns (uint256) {
+        // (a + b) / 2 can overflow, so we distribute
+        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
+    }
 }
diff --git a/contracts/math/SafeMath.sol b/contracts/math/SafeMath.sol
index 97494e1f1..f42c48e25 100644
--- a/contracts/math/SafeMath.sol
+++ b/contracts/math/SafeMath.sol
@@ -5,61 +5,61 @@ pragma solidity ^0.4.24;
  * @dev Math operations with safety checks that revert on error
  */
 library SafeMath {
+    /**
+    * @dev Multiplies two numbers, reverts on overflow.
+    */
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
+        // benefit is lost if 'b' is also tested.
+        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
+        if (a == 0) {
+            return 0;
+        }
 
-  /**
-  * @dev Multiplies two numbers, reverts on overflow.
-  */
-  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
-    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
-    // benefit is lost if 'b' is also tested.
-    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
-    if (a == 0) {
-      return 0;
+        uint256 c = a * b;
+        require(c / a == b);
+
+        return c;
     }
 
-    uint256 c = a * b;
-    require(c / a == b);
+    /**
+    * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
+    */
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        // Solidity only automatically asserts when dividing by 0
+        require(b > 0);
+        uint256 c = a / b;
+        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
 
-    return c;
-  }
+        return c;
+    }
 
-  /**
-  * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
-  */
-  function div(uint256 a, uint256 b) internal pure returns (uint256) {
-    require(b > 0); // Solidity only automatically asserts when dividing by 0
-    uint256 c = a / b;
-    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
+    /**
+    * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
+    */
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        require(b <= a);
+        uint256 c = a - b;
 
-    return c;
-  }
+        return c;
+    }
 
-  /**
-  * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
-  */
-  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
-    require(b <= a);
-    uint256 c = a - b;
+    /**
+    * @dev Adds two numbers, reverts on overflow.
+    */
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a);
 
-    return c;
-  }
+        return c;
+    }
 
-  /**
-  * @dev Adds two numbers, reverts on overflow.
-  */
-  function add(uint256 a, uint256 b) internal pure returns (uint256) {
-    uint256 c = a + b;
-    require(c >= a);
-
-    return c;
-  }
-
-  /**
-  * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
-  * reverts when dividing by zero.
-  */
-  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
-    require(b != 0);
-    return a % b;
-  }
+    /**
+    * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
+    * reverts when dividing by zero.
+    */
+    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
+        require(b != 0);
+        return a % b;
+    }
 }
diff --git a/contracts/mocks/AddressImpl.sol b/contracts/mocks/AddressImpl.sol
index e29396056..b60fe618f 100644
--- a/contracts/mocks/AddressImpl.sol
+++ b/contracts/mocks/AddressImpl.sol
@@ -3,12 +3,7 @@ pragma solidity ^0.4.24;
 import "../utils/Address.sol";
 
 contract AddressImpl {
-  function isContract(address account)
-    external
-    view
-    returns (bool)
-  {
-    return Address.isContract(account); 
-  }
-  
+    function isContract(address account) external view returns (bool) {
+        return Address.isContract(account);
+    }
 }
diff --git a/contracts/mocks/AllowanceCrowdsaleImpl.sol b/contracts/mocks/AllowanceCrowdsaleImpl.sol
index 5b2104e38..67e94fd48 100644
--- a/contracts/mocks/AllowanceCrowdsaleImpl.sol
+++ b/contracts/mocks/AllowanceCrowdsaleImpl.sol
@@ -4,17 +4,9 @@ import "../token/ERC20/IERC20.sol";
 import "../crowdsale/emission/AllowanceCrowdsale.sol";
 
 contract AllowanceCrowdsaleImpl is AllowanceCrowdsale {
-
-  constructor (
-    uint256 rate,
-    address wallet,
-    IERC20 token,
-    address tokenWallet
-  )
-    public
-    Crowdsale(rate, wallet, token)
-    AllowanceCrowdsale(tokenWallet)
-  {
-  }
-
+    constructor (uint256 rate, address wallet, IERC20 token, address tokenWallet)
+        public
+        Crowdsale(rate, wallet, token)
+        AllowanceCrowdsale(tokenWallet)
+    {}
 }
diff --git a/contracts/mocks/ArraysImpl.sol b/contracts/mocks/ArraysImpl.sol
index 8a2b9ec51..77c7a517b 100644
--- a/contracts/mocks/ArraysImpl.sol
+++ b/contracts/mocks/ArraysImpl.sol
@@ -3,16 +3,15 @@ pragma solidity ^0.4.24;
 import "../utils/Arrays.sol";
 
 contract ArraysImpl {
+    using Arrays for uint256[];
 
-  using Arrays for uint256[];
+    uint256[] private array;
 
-  uint256[] private array;
+    constructor (uint256[] _array) public {
+        array = _array;
+    }
 
-  constructor(uint256[] _array) public {
-    array = _array;
-  }
-
-  function findUpperBound(uint256 _element) external view returns (uint256) {
-    return array.findUpperBound(_element);
-  }
+    function findUpperBound(uint256 _element) external view returns (uint256) {
+        return array.findUpperBound(_element);
+    }
 }
diff --git a/contracts/mocks/CappedCrowdsaleImpl.sol b/contracts/mocks/CappedCrowdsaleImpl.sol
index 176033b7f..4b8cd5560 100644
--- a/contracts/mocks/CappedCrowdsaleImpl.sol
+++ b/contracts/mocks/CappedCrowdsaleImpl.sol
@@ -4,17 +4,9 @@ import "../token/ERC20/IERC20.sol";
 import "../crowdsale/validation/CappedCrowdsale.sol";
 
 contract CappedCrowdsaleImpl is CappedCrowdsale {
-
-  constructor (
-    uint256 rate,
-    address wallet,
-    IERC20 token,
-    uint256 cap
-  )
-    public
-    Crowdsale(rate, wallet, token)
-    CappedCrowdsale(cap)
-  {
-  }
-
+    constructor (uint256 rate, address wallet, IERC20 token, uint256 cap)
+        public
+        Crowdsale(rate, wallet, token)
+        CappedCrowdsale(cap)
+    {}
 }
diff --git a/contracts/mocks/CapperRoleMock.sol b/contracts/mocks/CapperRoleMock.sol
index 118058f39..eb3b92b62 100644
--- a/contracts/mocks/CapperRoleMock.sol
+++ b/contracts/mocks/CapperRoleMock.sol
@@ -3,15 +3,15 @@ pragma solidity ^0.4.24;
 import "../access/roles/CapperRole.sol";
 
 contract CapperRoleMock is CapperRole {
-  function removeCapper(address account) public {
-    _removeCapper(account);
-  }
+    function removeCapper(address account) public {
+        _removeCapper(account);
+    }
 
-  function onlyCapperMock() public view onlyCapper {
-  }
+    function onlyCapperMock() public view onlyCapper {
+    }
 
-  // Causes a compilation error if super._removeCapper is not internal
-  function _removeCapper(address account) internal {
-    super._removeCapper(account);
-  }
+    // Causes a compilation error if super._removeCapper is not internal
+    function _removeCapper(address account) internal {
+        super._removeCapper(account);
+    }
 }
diff --git a/contracts/mocks/ConditionalEscrowMock.sol b/contracts/mocks/ConditionalEscrowMock.sol
index 3e30c21a2..2f1faf804 100644
--- a/contracts/mocks/ConditionalEscrowMock.sol
+++ b/contracts/mocks/ConditionalEscrowMock.sol
@@ -4,13 +4,13 @@ import "../payment/escrow/ConditionalEscrow.sol";
 
 // mock class using ConditionalEscrow
 contract ConditionalEscrowMock is ConditionalEscrow {
-  mapping(address => bool) private _allowed;
+    mapping(address => bool) private _allowed;
 
-  function setAllowed(address payee, bool allowed) public {
-    _allowed[payee] = allowed;
-  }
+    function setAllowed(address payee, bool allowed) public {
+        _allowed[payee] = allowed;
+    }
 
-  function withdrawalAllowed(address payee) public view returns (bool) {
-    return _allowed[payee];
-  }
+    function withdrawalAllowed(address payee) public view returns (bool) {
+        return _allowed[payee];
+    }
 }
diff --git a/contracts/mocks/CounterImpl.sol b/contracts/mocks/CounterImpl.sol
index 3c958ba97..15ff1361e 100644
--- a/contracts/mocks/CounterImpl.sol
+++ b/contracts/mocks/CounterImpl.sol
@@ -3,18 +3,15 @@ pragma solidity ^0.4.24;
 import "../drafts/Counter.sol";
 
 contract CounterImpl {
-  using Counter for Counter.Counter;
+    using Counter for Counter.Counter;
 
-  uint256 public theId;
+    uint256 public theId;
 
-  // use whatever key you want to track your counters
-  mapping(string => Counter.Counter) private _counters;
+    // use whatever key you want to track your counters
+    mapping(string => Counter.Counter) private _counters;
 
-  function doThing(string key)
-    public
-    returns (uint256)
-  {
-    theId = _counters[key].next();
-    return theId;
-  }
+    function doThing(string key) public returns (uint256) {
+        theId = _counters[key].next();
+        return theId;
+    }
 }
diff --git a/contracts/mocks/CrowdsaleMock.sol b/contracts/mocks/CrowdsaleMock.sol
index 834105e6a..0555b1abc 100644
--- a/contracts/mocks/CrowdsaleMock.sol
+++ b/contracts/mocks/CrowdsaleMock.sol
@@ -3,7 +3,5 @@ pragma solidity ^0.4.24;
 import "../crowdsale/Crowdsale.sol";
 
 contract CrowdsaleMock is Crowdsale {
-  constructor(uint256 rate, address wallet, IERC20 token) public
-    Crowdsale(rate, wallet, token) {
-  }
+    constructor (uint256 rate, address wallet, IERC20 token) public Crowdsale(rate, wallet, token) {}
 }
diff --git a/contracts/mocks/DetailedERC20Mock.sol b/contracts/mocks/DetailedERC20Mock.sol
index eea706326..fbc526c45 100644
--- a/contracts/mocks/DetailedERC20Mock.sol
+++ b/contracts/mocks/DetailedERC20Mock.sol
@@ -4,12 +4,5 @@ import "../token/ERC20/ERC20.sol";
 import "../token/ERC20/ERC20Detailed.sol";
 
 contract ERC20DetailedMock is ERC20, ERC20Detailed {
-  constructor(
-    string name,
-    string symbol,
-    uint8 decimals
-  )
-    ERC20Detailed(name, symbol, decimals)
-    public
-  {}
+    constructor (string name, string symbol, uint8 decimals) ERC20Detailed(name, symbol, decimals) public {}
 }
diff --git a/contracts/mocks/ECDSAMock.sol b/contracts/mocks/ECDSAMock.sol
index 9f489069f..862ad9b35 100644
--- a/contracts/mocks/ECDSAMock.sol
+++ b/contracts/mocks/ECDSAMock.sol
@@ -3,21 +3,13 @@ pragma solidity ^0.4.24;
 import "../cryptography/ECDSA.sol";
 
 contract ECDSAMock {
-  using ECDSA for bytes32;
+    using ECDSA for bytes32;
 
-  function recover(bytes32 hash, bytes signature)
-    public
-    pure
-    returns (address)
-  {
-    return hash.recover(signature);
-  }
+    function recover(bytes32 hash, bytes signature) public pure returns (address) {
+        return hash.recover(signature);
+    }
 
-  function toEthSignedMessageHash(bytes32 hash)
-    public
-    pure
-    returns (bytes32)
-  {
-    return hash.toEthSignedMessageHash();
-  }
+    function toEthSignedMessageHash(bytes32 hash) public pure returns (bytes32) {
+        return hash.toEthSignedMessageHash();
+    }
 }
diff --git a/contracts/mocks/ERC165/ERC165InterfacesSupported.sol b/contracts/mocks/ERC165/ERC165InterfacesSupported.sol
index e41901a32..0ed65df24 100644
--- a/contracts/mocks/ERC165/ERC165InterfacesSupported.sol
+++ b/contracts/mocks/ERC165/ERC165InterfacesSupported.sol
@@ -11,56 +11,45 @@ import "../../introspection/IERC165.sol";
  * solidity-coverage ignores the /mocks folder, so we duplicate its implementation here to avoid instrumenting it
  */
 contract SupportsInterfaceWithLookupMock is IERC165 {
+    bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
+    /**
+     * 0x01ffc9a7 ===
+     *     bytes4(keccak256('supportsInterface(bytes4)'))
+     */
 
-  bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
-  /**
-   * 0x01ffc9a7 ===
-   *   bytes4(keccak256('supportsInterface(bytes4)'))
-   */
+    /**
+     * @dev a mapping of interface id to whether or not it's supported
+     */
+    mapping(bytes4 => bool) private _supportedInterfaces;
 
-  /**
-   * @dev a mapping of interface id to whether or not it's supported
-   */
-  mapping(bytes4 => bool) private _supportedInterfaces;
+    /**
+     * @dev A contract implementing SupportsInterfaceWithLookup
+     * implement ERC165 itself
+     */
+    constructor () public {
+        _registerInterface(InterfaceId_ERC165);
+    }
 
-  /**
-   * @dev A contract implementing SupportsInterfaceWithLookup
-   * implement ERC165 itself
-   */
-  constructor()
-    public
-  {
-    _registerInterface(InterfaceId_ERC165);
-  }
+    /**
+     * @dev implement supportsInterface(bytes4) using a lookup table
+     */
+    function supportsInterface(bytes4 interfaceId) external view returns (bool) {
+        return _supportedInterfaces[interfaceId];
+    }
 
-  /**
-   * @dev implement supportsInterface(bytes4) using a lookup table
-   */
-  function supportsInterface(bytes4 interfaceId)
-    external
-    view
-    returns (bool)
-  {
-    return _supportedInterfaces[interfaceId];
-  }
-
-  /**
-   * @dev private method for registering an interface
-   */
-  function _registerInterface(bytes4 interfaceId)
-    internal
-  {
-    require(interfaceId != 0xffffffff);
-    _supportedInterfaces[interfaceId] = true;
-  }
+    /**
+     * @dev private method for registering an interface
+     */
+    function _registerInterface(bytes4 interfaceId) internal {
+        require(interfaceId != 0xffffffff);
+        _supportedInterfaces[interfaceId] = true;
+    }
 }
 
 contract ERC165InterfacesSupported is SupportsInterfaceWithLookupMock {
-  constructor (bytes4[] interfaceIds)
-    public
-  {
-    for (uint256 i = 0; i < interfaceIds.length; i++) {
-      _registerInterface(interfaceIds[i]);
+    constructor (bytes4[] interfaceIds) public {
+        for (uint256 i = 0; i < interfaceIds.length; i++) {
+            _registerInterface(interfaceIds[i]);
+        }
     }
-  }
 }
diff --git a/contracts/mocks/ERC165/ERC165NotSupported.sol b/contracts/mocks/ERC165/ERC165NotSupported.sol
index 156ef8e8b..c1a39db19 100644
--- a/contracts/mocks/ERC165/ERC165NotSupported.sol
+++ b/contracts/mocks/ERC165/ERC165NotSupported.sol
@@ -1,5 +1,3 @@
 pragma solidity ^0.4.24;
 
-contract ERC165NotSupported {
-
-}
+contract ERC165NotSupported {}
diff --git a/contracts/mocks/ERC165CheckerMock.sol b/contracts/mocks/ERC165CheckerMock.sol
index 559cea0d7..b85397b44 100644
--- a/contracts/mocks/ERC165CheckerMock.sol
+++ b/contracts/mocks/ERC165CheckerMock.sol
@@ -3,29 +3,17 @@ pragma solidity ^0.4.24;
 import "../introspection/ERC165Checker.sol";
 
 contract ERC165CheckerMock {
-  using ERC165Checker for address;
+    using ERC165Checker for address;
 
-  function supportsERC165(address account)
-    public
-    view
-    returns (bool)
-  {
-    return account._supportsERC165();
-  }
+    function supportsERC165(address account) public view returns (bool) {
+        return account._supportsERC165();
+    }
 
-  function supportsInterface(address account, bytes4 interfaceId)
-    public
-    view
-    returns (bool)
-  {
-    return account._supportsInterface(interfaceId);
-  }
+    function supportsInterface(address account, bytes4 interfaceId) public view returns (bool) {
+        return account._supportsInterface(interfaceId);
+    }
 
-  function supportsAllInterfaces(address account, bytes4[] interfaceIds)
-    public
-    view
-    returns (bool)
-  {
-    return account._supportsAllInterfaces(interfaceIds);
-  }
+    function supportsAllInterfaces(address account, bytes4[] interfaceIds) public view returns (bool) {
+        return account._supportsAllInterfaces(interfaceIds);
+    }
 }
diff --git a/contracts/mocks/ERC165Mock.sol b/contracts/mocks/ERC165Mock.sol
index c42ba62f2..ad48a9de3 100644
--- a/contracts/mocks/ERC165Mock.sol
+++ b/contracts/mocks/ERC165Mock.sol
@@ -3,9 +3,7 @@ pragma solidity ^0.4.24;
 import "../introspection/ERC165.sol";
 
 contract ERC165Mock is ERC165 {
-  function registerInterface(bytes4 interfaceId)
-    public
-  {
-    _registerInterface(interfaceId);
-  }
+    function registerInterface(bytes4 interfaceId) public {
+        _registerInterface(interfaceId);
+    }
 }
diff --git a/contracts/mocks/ERC20BurnableMock.sol b/contracts/mocks/ERC20BurnableMock.sol
index 2c8b3b54a..7456f9642 100644
--- a/contracts/mocks/ERC20BurnableMock.sol
+++ b/contracts/mocks/ERC20BurnableMock.sol
@@ -3,9 +3,7 @@ pragma solidity ^0.4.24;
 import "../token/ERC20/ERC20Burnable.sol";
 
 contract ERC20BurnableMock is ERC20Burnable {
-
-  constructor(address initialAccount, uint256 initialBalance) public {
-    _mint(initialAccount, initialBalance);
-  }
-
+    constructor (address initialAccount, uint256 initialBalance) public {
+        _mint(initialAccount, initialBalance);
+    }
 }
diff --git a/contracts/mocks/ERC20Mock.sol b/contracts/mocks/ERC20Mock.sol
index ab0877653..3742f808d 100644
--- a/contracts/mocks/ERC20Mock.sol
+++ b/contracts/mocks/ERC20Mock.sol
@@ -4,21 +4,19 @@ import "../token/ERC20/ERC20.sol";
 
 // mock class using ERC20
 contract ERC20Mock is ERC20 {
+    constructor (address initialAccount, uint256 initialBalance) public {
+        _mint(initialAccount, initialBalance);
+    }
 
-  constructor(address initialAccount, uint256 initialBalance) public {
-    _mint(initialAccount, initialBalance);
-  }
+    function mint(address account, uint256 amount) public {
+        _mint(account, amount);
+    }
 
-  function mint(address account, uint256 amount) public {
-    _mint(account, amount);
-  }
-
-  function burn(address account, uint256 amount) public {
-    _burn(account, amount);
-  }
-
-  function burnFrom(address account, uint256 amount) public {
-    _burnFrom(account, amount);
-  }
+    function burn(address account, uint256 amount) public {
+        _burn(account, amount);
+    }
 
+    function burnFrom(address account, uint256 amount) public {
+        _burnFrom(account, amount);
+    }
 }
diff --git a/contracts/mocks/ERC20PausableMock.sol b/contracts/mocks/ERC20PausableMock.sol
index c6c0fd5ed..59a8a0952 100644
--- a/contracts/mocks/ERC20PausableMock.sol
+++ b/contracts/mocks/ERC20PausableMock.sol
@@ -5,9 +5,7 @@ import "./PauserRoleMock.sol";
 
 // mock class using ERC20Pausable
 contract ERC20PausableMock is ERC20Pausable, PauserRoleMock {
-
-  constructor(address initialAccount, uint initialBalance) public {
-    _mint(initialAccount, initialBalance);
-  }
-
+    constructor (address initialAccount, uint initialBalance) public {
+        _mint(initialAccount, initialBalance);
+    }
 }
diff --git a/contracts/mocks/ERC20WithMetadataMock.sol b/contracts/mocks/ERC20WithMetadataMock.sol
index ec2d122a1..6eb4b9306 100644
--- a/contracts/mocks/ERC20WithMetadataMock.sol
+++ b/contracts/mocks/ERC20WithMetadataMock.sol
@@ -4,8 +4,5 @@ import "../token/ERC20/ERC20.sol";
 import "../drafts/ERC1046/TokenMetadata.sol";
 
 contract ERC20WithMetadataMock is ERC20, ERC20WithMetadata {
-  constructor(string tokenURI) public
-    ERC20WithMetadata(tokenURI)
-  {
-  }
+    constructor (string tokenURI) public ERC20WithMetadata(tokenURI) {}
 }
diff --git a/contracts/mocks/ERC721FullMock.sol b/contracts/mocks/ERC721FullMock.sol
index 2d85e7372..5199ef417 100644
--- a/contracts/mocks/ERC721FullMock.sol
+++ b/contracts/mocks/ERC721FullMock.sol
@@ -10,23 +10,18 @@ import "../token/ERC721/ERC721Burnable.sol";
  * This mock just provides a public mint and burn functions for testing purposes,
  * and a public setter for metadata URI
  */
-contract ERC721FullMock
-  is ERC721Full, ERC721Mintable, ERC721MetadataMintable, ERC721Burnable {
+contract ERC721FullMock is ERC721Full, ERC721Mintable, ERC721MetadataMintable, ERC721Burnable {
+    constructor (string name, string symbol) public ERC721Mintable() ERC721Full(name, symbol) {}
 
-  constructor(string name, string symbol) public
-    ERC721Mintable()
-    ERC721Full(name, symbol)
-  {}
+    function exists(uint256 tokenId) public view returns (bool) {
+        return _exists(tokenId);
+    }
 
-  function exists(uint256 tokenId) public view returns (bool) {
-    return _exists(tokenId);
-  }
+    function setTokenURI(uint256 tokenId, string uri) public {
+        _setTokenURI(tokenId, uri);
+    }
 
-  function setTokenURI(uint256 tokenId, string uri) public {
-    _setTokenURI(tokenId, uri);
-  }
-
-  function removeTokenFrom(address from, uint256 tokenId) public {
-    _removeTokenFrom(from, tokenId);
-  }
+    function removeTokenFrom(address from, uint256 tokenId) public {
+        _removeTokenFrom(from, tokenId);
+    }
 }
diff --git a/contracts/mocks/ERC721MintableBurnableImpl.sol b/contracts/mocks/ERC721MintableBurnableImpl.sol
index 51d3ff4f6..6e5aae6f5 100644
--- a/contracts/mocks/ERC721MintableBurnableImpl.sol
+++ b/contracts/mocks/ERC721MintableBurnableImpl.sol
@@ -8,13 +8,6 @@ import "../token/ERC721/ERC721Burnable.sol";
 /**
  * @title ERC721MintableBurnableImpl
  */
-contract ERC721MintableBurnableImpl
-  is ERC721Full, ERC721Mintable, ERC721MetadataMintable, ERC721Burnable {
-
-  constructor()
-    ERC721Mintable()
-    ERC721Full("Test", "TEST")
-    public
-  {
-  }
+contract ERC721MintableBurnableImpl is ERC721Full, ERC721Mintable, ERC721MetadataMintable, ERC721Burnable {
+    constructor () ERC721Mintable() ERC721Full("Test", "TEST") public {}
 }
diff --git a/contracts/mocks/ERC721Mock.sol b/contracts/mocks/ERC721Mock.sol
index 514d3bdbe..98bfe99bc 100644
--- a/contracts/mocks/ERC721Mock.sol
+++ b/contracts/mocks/ERC721Mock.sol
@@ -7,11 +7,11 @@ import "../token/ERC721/ERC721.sol";
  * This mock just provides a public mint and burn functions for testing purposes
  */
 contract ERC721Mock is ERC721 {
-  function mint(address to, uint256 tokenId) public {
-    _mint(to, tokenId);
-  }
+    function mint(address to, uint256 tokenId) public {
+        _mint(to, tokenId);
+    }
 
-  function burn(uint256 tokenId) public {
-    _burn(ownerOf(tokenId), tokenId);
-  }
+    function burn(uint256 tokenId) public {
+        _burn(ownerOf(tokenId), tokenId);
+    }
 }
diff --git a/contracts/mocks/ERC721PausableMock.sol b/contracts/mocks/ERC721PausableMock.sol
index 9751d04cb..4470ea726 100644
--- a/contracts/mocks/ERC721PausableMock.sol
+++ b/contracts/mocks/ERC721PausableMock.sol
@@ -8,15 +8,15 @@ import "./PauserRoleMock.sol";
  * This mock just provides a public mint, burn and exists functions for testing purposes
  */
 contract ERC721PausableMock is ERC721Pausable, PauserRoleMock {
-  function mint(address to, uint256 tokenId) public {
-    super._mint(to, tokenId);
-  }
+    function mint(address to, uint256 tokenId) public {
+        super._mint(to, tokenId);
+    }
 
-  function burn(uint256 tokenId) public {
-    super._burn(ownerOf(tokenId), tokenId);
-  }
+    function burn(uint256 tokenId) public {
+        super._burn(ownerOf(tokenId), tokenId);
+    }
 
-  function exists(uint256 tokenId) public view returns (bool) {
-    return super._exists(tokenId);
-  }
+    function exists(uint256 tokenId) public view returns (bool) {
+        return super._exists(tokenId);
+    }
 }
diff --git a/contracts/mocks/ERC721ReceiverMock.sol b/contracts/mocks/ERC721ReceiverMock.sol
index 57fb04e3a..7e469b271 100644
--- a/contracts/mocks/ERC721ReceiverMock.sol
+++ b/contracts/mocks/ERC721ReceiverMock.sol
@@ -3,39 +3,19 @@ pragma solidity ^0.4.24;
 import "../token/ERC721/IERC721Receiver.sol";
 
 contract ERC721ReceiverMock is IERC721Receiver {
-  bytes4 private _retval;
-  bool private _reverts;
+    bytes4 private _retval;
+    bool private _reverts;
 
-  event Received(
-    address operator,
-    address from,
-    uint256 tokenId,
-    bytes data,
-    uint256 gas
-  );
+    event Received(address operator, address from, uint256 tokenId, bytes data, uint256 gas);
 
-  constructor(bytes4 retval, bool reverts) public {
-    _retval = retval;
-    _reverts = reverts;
-  }
+    constructor (bytes4 retval, bool reverts) public {
+        _retval = retval;
+        _reverts = reverts;
+    }
 
-  function onERC721Received(
-    address operator,
-    address from,
-    uint256 tokenId,
-    bytes data
-  )
-    public
-    returns(bytes4)
-  {
-    require(!_reverts);
-    emit Received(
-      operator,
-      from,
-      tokenId,
-      data,
-      gasleft() // msg.gas was deprecated in solidityv0.4.21
-    );
-    return _retval;
-  }
+    function onERC721Received(address operator, address from, uint256 tokenId, bytes data) public returns (bytes4) {
+        require(!_reverts);
+        emit Received(operator, from, tokenId, data, gasleft());
+        return _retval;
+    }
 }
diff --git a/contracts/mocks/EventEmitter.sol b/contracts/mocks/EventEmitter.sol
index 71582d9f5..257b23651 100644
--- a/contracts/mocks/EventEmitter.sol
+++ b/contracts/mocks/EventEmitter.sol
@@ -1,62 +1,54 @@
 pragma solidity ^0.4.24;
 
 contract EventEmitter {
-  event Argumentless();
-  event ShortUint(uint8 value);
-  event ShortInt(int8 value);
-  event LongUint(uint256 value);
-  event LongInt(int256 value);
-  event Address(address value);
-  event Boolean(bool value);
-  event String(string value);
-  event LongUintBooleanString(
-    uint256 uintValue,
-    bool booleanValue,
-    string stringValue
-  );
+    event Argumentless();
+    event ShortUint(uint8 value);
+    event ShortInt(int8 value);
+    event LongUint(uint256 value);
+    event LongInt(int256 value);
+    event Address(address value);
+    event Boolean(bool value);
+    event String(string value);
+    event LongUintBooleanString(uint256 uintValue, bool booleanValue, string stringValue);
 
-  function emitArgumentless() public {
-    emit Argumentless();
-  }
+    function emitArgumentless() public {
+        emit Argumentless();
+    }
 
-  function emitShortUint(uint8 value) public {
-    emit ShortUint(value);
-  }
+    function emitShortUint(uint8 value) public {
+        emit ShortUint(value);
+    }
 
-  function emitShortInt(int8 value) public {
-    emit ShortInt(value);
-  }
+    function emitShortInt(int8 value) public {
+        emit ShortInt(value);
+    }
 
-  function emitLongUint(uint256 value) public {
-    emit LongUint(value);
-  }
+    function emitLongUint(uint256 value) public {
+        emit LongUint(value);
+    }
 
-  function emitLongInt(int256 value) public {
-    emit LongInt(value);
-  }
+    function emitLongInt(int256 value) public {
+        emit LongInt(value);
+    }
 
-  function emitAddress(address value) public {
-    emit Address(value);
-  }
+    function emitAddress(address value) public {
+        emit Address(value);
+    }
 
-  function emitBoolean(bool value) public {
-    emit Boolean(value);
-  }
+    function emitBoolean(bool value) public {
+        emit Boolean(value);
+    }
 
-  function emitString(string value) public {
-    emit String(value);
-  }
+    function emitString(string value) public {
+        emit String(value);
+    }
 
-  function emitLongUintBooleanString(
-    uint256 uintValue,
-    bool booleanValue,
-    string stringValue)
-  public {
-    emit LongUintBooleanString(uintValue, booleanValue, stringValue);
-  }
+    function emitLongUintBooleanString(uint256 uintValue, bool booleanValue, string stringValue) public {
+        emit LongUintBooleanString(uintValue, booleanValue, stringValue);
+    }
 
-  function emitLongUintAndBoolean(uint256 uintValue, bool boolValue) public {
-    emit LongUint(uintValue);
-    emit Boolean(boolValue);
-  }
+    function emitLongUintAndBoolean(uint256 uintValue, bool boolValue) public {
+        emit LongUint(uintValue);
+        emit Boolean(boolValue);
+    }
 }
diff --git a/contracts/mocks/FinalizableCrowdsaleImpl.sol b/contracts/mocks/FinalizableCrowdsaleImpl.sol
index 084780b1d..0dee94ff1 100644
--- a/contracts/mocks/FinalizableCrowdsaleImpl.sol
+++ b/contracts/mocks/FinalizableCrowdsaleImpl.sol
@@ -5,17 +5,9 @@ import "../crowdsale/distribution/FinalizableCrowdsale.sol";
 
 contract FinalizableCrowdsaleImpl is FinalizableCrowdsale {
 
-  constructor (
-    uint256 openingTime,
-    uint256 closingTime,
-    uint256 rate,
-    address wallet,
-    IERC20 token
-  )
-    public
-    Crowdsale(rate, wallet, token)
-    TimedCrowdsale(openingTime, closingTime)
-  {
-  }
-
+    constructor (uint256 openingTime, uint256 closingTime, uint256 rate, address wallet, IERC20 token)
+        public
+        Crowdsale(rate, wallet, token)
+        TimedCrowdsale(openingTime, closingTime)
+    {}
 }
diff --git a/contracts/mocks/IncreasingPriceCrowdsaleImpl.sol b/contracts/mocks/IncreasingPriceCrowdsaleImpl.sol
index 6f1f2e2a0..3f5d30b21 100644
--- a/contracts/mocks/IncreasingPriceCrowdsaleImpl.sol
+++ b/contracts/mocks/IncreasingPriceCrowdsaleImpl.sol
@@ -4,20 +4,17 @@ import "../crowdsale/price/IncreasingPriceCrowdsale.sol";
 import "../math/SafeMath.sol";
 
 contract IncreasingPriceCrowdsaleImpl is IncreasingPriceCrowdsale {
-
-  constructor (
-    uint256 openingTime,
-    uint256 closingTime,
-    address wallet,
-    IERC20 token,
-    uint256 initialRate,
-    uint256 finalRate
-  )
-    public
-    Crowdsale(initialRate, wallet, token)
-    TimedCrowdsale(openingTime, closingTime)
-    IncreasingPriceCrowdsale(initialRate, finalRate)
-  {
-  }
-
+    constructor (
+        uint256 openingTime,
+        uint256 closingTime,
+        address wallet,
+        IERC20 token,
+        uint256 initialRate,
+        uint256 finalRate
+    )
+        public
+        Crowdsale(initialRate, wallet, token)
+        TimedCrowdsale(openingTime, closingTime)
+        IncreasingPriceCrowdsale(initialRate, finalRate)
+    {}
 }
diff --git a/contracts/mocks/IndividuallyCappedCrowdsaleImpl.sol b/contracts/mocks/IndividuallyCappedCrowdsaleImpl.sol
index 1bcb95301..296dbc26f 100644
--- a/contracts/mocks/IndividuallyCappedCrowdsaleImpl.sol
+++ b/contracts/mocks/IndividuallyCappedCrowdsaleImpl.sol
@@ -4,16 +4,7 @@ import "../token/ERC20/IERC20.sol";
 import "../crowdsale/validation/IndividuallyCappedCrowdsale.sol";
 import "./CapperRoleMock.sol";
 
-contract IndividuallyCappedCrowdsaleImpl
-  is IndividuallyCappedCrowdsale, CapperRoleMock {
-
-  constructor(
-    uint256 rate,
-    address wallet,
-    IERC20 token
-  )
-    public
-    Crowdsale(rate, wallet, token)
-  {
-  }
+contract IndividuallyCappedCrowdsaleImpl is IndividuallyCappedCrowdsale, CapperRoleMock {
+    constructor (uint256 rate, address wallet, IERC20 token) public Crowdsale(rate, wallet, token)
+    {}
 }
diff --git a/contracts/mocks/MathMock.sol b/contracts/mocks/MathMock.sol
index 72f7fc204..c6d1f107a 100644
--- a/contracts/mocks/MathMock.sol
+++ b/contracts/mocks/MathMock.sol
@@ -3,15 +3,15 @@ pragma solidity ^0.4.24;
 import "../math/Math.sol";
 
 contract MathMock {
-  function max(uint256 a, uint256 b) public pure returns (uint256) {
-    return Math.max(a, b);
-  }
+    function max(uint256 a, uint256 b) public pure returns (uint256) {
+        return Math.max(a, b);
+    }
 
-  function min(uint256 a, uint256 b) public pure returns (uint256) {
-    return Math.min(a, b);
-  }
+    function min(uint256 a, uint256 b) public pure returns (uint256) {
+        return Math.min(a, b);
+    }
 
-  function average(uint256 a, uint256 b) public pure returns (uint256) {
-    return Math.average(a, b);
-  }
+    function average(uint256 a, uint256 b) public pure returns (uint256) {
+        return Math.average(a, b);
+    }
 }
diff --git a/contracts/mocks/MerkleProofWrapper.sol b/contracts/mocks/MerkleProofWrapper.sol
index b359dc790..02a1d8cc6 100644
--- a/contracts/mocks/MerkleProofWrapper.sol
+++ b/contracts/mocks/MerkleProofWrapper.sol
@@ -3,16 +3,7 @@ pragma solidity ^0.4.24;
 import { MerkleProof } from "../cryptography/MerkleProof.sol";
 
 contract MerkleProofWrapper {
-
-  function verify(
-    bytes32[] proof,
-    bytes32 root,
-    bytes32 leaf
-  )
-    public
-    pure
-    returns (bool)
-  {
-    return MerkleProof.verify(proof, root, leaf);
-  }
+    function verify(bytes32[] proof, bytes32 root, bytes32 leaf) public pure returns (bool) {
+        return MerkleProof.verify(proof, root, leaf);
+    }
 }
diff --git a/contracts/mocks/MintedCrowdsaleImpl.sol b/contracts/mocks/MintedCrowdsaleImpl.sol
index 518371b75..48d6c167d 100644
--- a/contracts/mocks/MintedCrowdsaleImpl.sol
+++ b/contracts/mocks/MintedCrowdsaleImpl.sol
@@ -4,15 +4,5 @@ import "../token/ERC20/ERC20Mintable.sol";
 import "../crowdsale/emission/MintedCrowdsale.sol";
 
 contract MintedCrowdsaleImpl is MintedCrowdsale {
-
-  constructor (
-    uint256 rate,
-    address wallet,
-    ERC20Mintable token
-  )
-    public
-    Crowdsale(rate, wallet, token)
-  {
-  }
-
+    constructor (uint256 rate, address wallet, ERC20Mintable token) public Crowdsale(rate, wallet, token) {}
 }
diff --git a/contracts/mocks/MinterRoleMock.sol b/contracts/mocks/MinterRoleMock.sol
index 45e5a4195..0755c1221 100644
--- a/contracts/mocks/MinterRoleMock.sol
+++ b/contracts/mocks/MinterRoleMock.sol
@@ -3,15 +3,15 @@ pragma solidity ^0.4.24;
 import "../access/roles/MinterRole.sol";
 
 contract MinterRoleMock is MinterRole {
-  function removeMinter(address account) public {
-    _removeMinter(account);
-  }
+    function removeMinter(address account) public {
+        _removeMinter(account);
+    }
 
-  function onlyMinterMock() public view onlyMinter {
-  }
+    function onlyMinterMock() public view onlyMinter {
+    }
 
-  // Causes a compilation error if super._removeMinter is not internal
-  function _removeMinter(address account) internal {
-    super._removeMinter(account);
-  }
+    // Causes a compilation error if super._removeMinter is not internal
+    function _removeMinter(address account) internal {
+        super._removeMinter(account);
+    }
 }
diff --git a/contracts/mocks/OwnableMock.sol b/contracts/mocks/OwnableMock.sol
index e16a89012..6a1bf1e2c 100644
--- a/contracts/mocks/OwnableMock.sol
+++ b/contracts/mocks/OwnableMock.sol
@@ -2,5 +2,4 @@ pragma solidity ^0.4.24;
 
 import "../ownership/Ownable.sol";
 
-contract OwnableMock is Ownable {
-}
+contract OwnableMock is Ownable {}
diff --git a/contracts/mocks/PausableMock.sol b/contracts/mocks/PausableMock.sol
index 72ec843ed..c2dcda1c5 100644
--- a/contracts/mocks/PausableMock.sol
+++ b/contracts/mocks/PausableMock.sol
@@ -5,20 +5,19 @@ import "./PauserRoleMock.sol";
 
 // mock class using Pausable
 contract PausableMock is Pausable, PauserRoleMock {
-  bool public drasticMeasureTaken;
-  uint256 public count;
+    bool public drasticMeasureTaken;
+    uint256 public count;
 
-  constructor() public {
-    drasticMeasureTaken = false;
-    count = 0;
-  }
+    constructor () public {
+        drasticMeasureTaken = false;
+        count = 0;
+    }
 
-  function normalProcess() external whenNotPaused {
-    count++;
-  }
-
-  function drasticMeasure() external whenPaused {
-    drasticMeasureTaken = true;
-  }
+    function normalProcess() external whenNotPaused {
+        count++;
+    }
 
+    function drasticMeasure() external whenPaused {
+        drasticMeasureTaken = true;
+    }
 }
diff --git a/contracts/mocks/PauserRoleMock.sol b/contracts/mocks/PauserRoleMock.sol
index 267101e4a..22f03f5b0 100644
--- a/contracts/mocks/PauserRoleMock.sol
+++ b/contracts/mocks/PauserRoleMock.sol
@@ -3,15 +3,15 @@ pragma solidity ^0.4.24;
 import "../access/roles/PauserRole.sol";
 
 contract PauserRoleMock is PauserRole {
-  function removePauser(address account) public {
-    _removePauser(account);
-  }
+    function removePauser(address account) public {
+        _removePauser(account);
+    }
 
-  function onlyPauserMock() public view onlyPauser {
-  }
+    function onlyPauserMock() public view onlyPauser {
+    }
 
-  // Causes a compilation error if super._removePauser is not internal
-  function _removePauser(address account) internal {
-    super._removePauser(account);
-  }
+    // Causes a compilation error if super._removePauser is not internal
+    function _removePauser(address account) internal {
+        super._removePauser(account);
+    }
 }
diff --git a/contracts/mocks/PostDeliveryCrowdsaleImpl.sol b/contracts/mocks/PostDeliveryCrowdsaleImpl.sol
index 98d056c66..df71456c7 100644
--- a/contracts/mocks/PostDeliveryCrowdsaleImpl.sol
+++ b/contracts/mocks/PostDeliveryCrowdsaleImpl.sol
@@ -4,18 +4,9 @@ import "../token/ERC20/IERC20.sol";
 import "../crowdsale/distribution/PostDeliveryCrowdsale.sol";
 
 contract PostDeliveryCrowdsaleImpl is PostDeliveryCrowdsale {
-
-  constructor (
-    uint256 openingTime,
-    uint256 closingTime,
-    uint256 rate,
-    address wallet,
-    IERC20 token
-  )
-    public
-    TimedCrowdsale(openingTime, closingTime)
-    Crowdsale(rate, wallet, token)
-  {
-  }
-
+    constructor (uint256 openingTime, uint256 closingTime, uint256 rate, address wallet, IERC20 token)
+        public
+        TimedCrowdsale(openingTime, closingTime)
+        Crowdsale(rate, wallet, token)
+    {}
 }
diff --git a/contracts/mocks/PullPaymentMock.sol b/contracts/mocks/PullPaymentMock.sol
index 63076c904..d35e97e02 100644
--- a/contracts/mocks/PullPaymentMock.sol
+++ b/contracts/mocks/PullPaymentMock.sol
@@ -4,12 +4,10 @@ import "../payment/PullPayment.sol";
 
 // mock class using PullPayment
 contract PullPaymentMock is PullPayment {
+    constructor () public payable { }
 
-  constructor() public payable { }
-
-  // test helper function to call asyncTransfer
-  function callTransfer(address dest, uint256 amount) public {
-    _asyncTransfer(dest, amount);
-  }
-
+    // test helper function to call asyncTransfer
+    function callTransfer(address dest, uint256 amount) public {
+        _asyncTransfer(dest, amount);
+    }
 }
diff --git a/contracts/mocks/ReentrancyAttack.sol b/contracts/mocks/ReentrancyAttack.sol
index 96231de27..c18a1020b 100644
--- a/contracts/mocks/ReentrancyAttack.sol
+++ b/contracts/mocks/ReentrancyAttack.sol
@@ -2,9 +2,9 @@ pragma solidity ^0.4.24;
 
 contract ReentrancyAttack {
 
-  function callSender(bytes4 data) public {
-    // solium-disable-next-line security/no-low-level-calls
-    require(msg.sender.call(abi.encodeWithSelector(data)));
-  }
+    function callSender(bytes4 data) public {
+        // solium-disable-next-line security/no-low-level-calls
+        require(msg.sender.call(abi.encodeWithSelector(data)));
+    }
 
 }
diff --git a/contracts/mocks/ReentrancyMock.sol b/contracts/mocks/ReentrancyMock.sol
index 474ecd433..5aac7603c 100644
--- a/contracts/mocks/ReentrancyMock.sol
+++ b/contracts/mocks/ReentrancyMock.sol
@@ -4,41 +4,39 @@ import "../utils/ReentrancyGuard.sol";
 import "./ReentrancyAttack.sol";
 
 contract ReentrancyMock is ReentrancyGuard {
+    uint256 public counter;
 
-  uint256 public counter;
-
-  constructor() public {
-    counter = 0;
-  }
-
-  function callback() external nonReentrant {
-    count();
-  }
-
-  function countLocalRecursive(uint256 n) public nonReentrant {
-    if (n > 0) {
-      count();
-      countLocalRecursive(n - 1);
+    constructor () public {
+        counter = 0;
     }
-  }
 
-  function countThisRecursive(uint256 n) public nonReentrant {
-    if (n > 0) {
-      count();
-      // solium-disable-next-line security/no-low-level-calls
-      bool result = address(this).call(abi.encodeWithSignature("countThisRecursive(uint256)", n - 1));
-      require(result == true);
+    function callback() external nonReentrant {
+        count();
     }
-  }
 
-  function countAndCall(ReentrancyAttack attacker) public nonReentrant {
-    count();
-    bytes4 func = bytes4(keccak256("callback()"));
-    attacker.callSender(func);
-  }
+    function countLocalRecursive(uint256 n) public nonReentrant {
+        if (n > 0) {
+            count();
+            countLocalRecursive(n - 1);
+        }
+    }
 
-  function count() private {
-    counter += 1;
-  }
+    function countThisRecursive(uint256 n) public nonReentrant {
+        if (n > 0) {
+            count();
+            // solium-disable-next-line security/no-low-level-calls
+            bool result = address(this).call(abi.encodeWithSignature("countThisRecursive(uint256)", n - 1));
+            require(result == true);
+        }
+    }
 
+    function countAndCall(ReentrancyAttack attacker) public nonReentrant {
+        count();
+        bytes4 func = bytes4(keccak256("callback()"));
+        attacker.callSender(func);
+    }
+
+    function count() private {
+        counter += 1;
+    }
 }
diff --git a/contracts/mocks/RefundableCrowdsaleImpl.sol b/contracts/mocks/RefundableCrowdsaleImpl.sol
index a14dfbcb3..6759d9aff 100644
--- a/contracts/mocks/RefundableCrowdsaleImpl.sol
+++ b/contracts/mocks/RefundableCrowdsaleImpl.sol
@@ -4,20 +4,17 @@ import "../token/ERC20/ERC20Mintable.sol";
 import "../crowdsale/distribution/RefundableCrowdsale.sol";
 
 contract RefundableCrowdsaleImpl is RefundableCrowdsale {
-
-  constructor (
-    uint256 openingTime,
-    uint256 closingTime,
-    uint256 rate,
-    address wallet,
-    ERC20Mintable token,
-    uint256 goal
-  )
-    public
-    Crowdsale(rate, wallet, token)
-    TimedCrowdsale(openingTime, closingTime)
-    RefundableCrowdsale(goal)
-  {
-  }
-
+    constructor (
+        uint256 openingTime,
+        uint256 closingTime,
+        uint256 rate,
+        address wallet,
+        ERC20Mintable token,
+        uint256 goal
+    )
+        public
+        Crowdsale(rate, wallet, token)
+        TimedCrowdsale(openingTime, closingTime)
+        RefundableCrowdsale(goal)
+    {}
 }
diff --git a/contracts/mocks/RolesMock.sol b/contracts/mocks/RolesMock.sol
index bfcee20ee..db71ca536 100644
--- a/contracts/mocks/RolesMock.sol
+++ b/contracts/mocks/RolesMock.sol
@@ -3,19 +3,19 @@ pragma solidity ^0.4.24;
 import "../access/Roles.sol";
 
 contract RolesMock {
-  using Roles for Roles.Role;
+    using Roles for Roles.Role;
 
-  Roles.Role private dummyRole;
+    Roles.Role private dummyRole;
 
-  function add(address account) public {
-    dummyRole.add(account);
-  }
+    function add(address account) public {
+        dummyRole.add(account);
+    }
 
-  function remove(address account) public {
-    dummyRole.remove(account);
-  }
+    function remove(address account) public {
+        dummyRole.remove(account);
+    }
 
-  function has(address account) public view returns (bool) {
-    return dummyRole.has(account);
-  }
+    function has(address account) public view returns (bool) {
+        return dummyRole.has(account);
+    }
 }
diff --git a/contracts/mocks/SafeERC20Helper.sol b/contracts/mocks/SafeERC20Helper.sol
index 7e639f86f..9c0af1312 100644
--- a/contracts/mocks/SafeERC20Helper.sol
+++ b/contracts/mocks/SafeERC20Helper.sol
@@ -4,109 +4,109 @@ import "../token/ERC20/IERC20.sol";
 import "../token/ERC20/SafeERC20.sol";
 
 contract ERC20FailingMock {
-  uint256 private _allowance;
+    uint256 private _allowance;
 
-  function transfer(address, uint256) public returns (bool) {
-    return false;
-  }
+    function transfer(address, uint256) public returns (bool) {
+        return false;
+    }
 
-  function transferFrom(address, address, uint256) public returns (bool) {
-    return false;
-  }
+    function transferFrom(address, address, uint256) public returns (bool) {
+        return false;
+    }
 
-  function approve(address, uint256) public returns (bool) {
-    return false;
-  }
+    function approve(address, uint256) public returns (bool) {
+        return false;
+    }
 
-  function allowance(address, address) public view returns (uint256) {
-    return 0;
-  }
+    function allowance(address, address) public view returns (uint256) {
+        return 0;
+    }
 }
 
 contract ERC20SucceedingMock {
-  uint256 private _allowance;
+    uint256 private _allowance;
 
-  function transfer(address, uint256) public returns (bool) {
-    return true;
-  }
+    function transfer(address, uint256) public returns (bool) {
+        return true;
+    }
 
-  function transferFrom(address, address, uint256) public returns (bool) {
-    return true;
-  }
+    function transferFrom(address, address, uint256) public returns (bool) {
+        return true;
+    }
 
-  function approve(address, uint256) public returns (bool) {
-    return true;
-  }
+    function approve(address, uint256) public returns (bool) {
+        return true;
+    }
 
-  function setAllowance(uint256 allowance_) public {
-    _allowance = allowance_;
-  }
+    function setAllowance(uint256 allowance_) public {
+        _allowance = allowance_;
+    }
 
-  function allowance(address, address) public view returns (uint256) {
-    return _allowance;
-  }
+    function allowance(address, address) public view returns (uint256) {
+        return _allowance;
+    }
 }
 
 contract SafeERC20Helper {
-  using SafeERC20 for IERC20;
+    using SafeERC20 for IERC20;
 
-  IERC20 private _failing;
-  IERC20 private _succeeding;
+    IERC20 private _failing;
+    IERC20 private _succeeding;
 
-  constructor() public {
-    _failing = IERC20(new ERC20FailingMock());
-    _succeeding = IERC20(new ERC20SucceedingMock());
-  }
+    constructor () public {
+        _failing = IERC20(new ERC20FailingMock());
+        _succeeding = IERC20(new ERC20SucceedingMock());
+    }
 
-  // Using _failing
+    // Using _failing
 
-  function doFailingTransfer() public {
-    _failing.safeTransfer(address(0), 0);
-  }
+    function doFailingTransfer() public {
+        _failing.safeTransfer(address(0), 0);
+    }
 
-  function doFailingTransferFrom() public {
-    _failing.safeTransferFrom(address(0), address(0), 0);
-  }
+    function doFailingTransferFrom() public {
+        _failing.safeTransferFrom(address(0), address(0), 0);
+    }
 
-  function doFailingApprove() public {
-    _failing.safeApprove(address(0), 0);
-  }
+    function doFailingApprove() public {
+        _failing.safeApprove(address(0), 0);
+    }
 
-  function doFailingIncreaseAllowance() public {
-    _failing.safeIncreaseAllowance(address(0), 0);
-  }
+    function doFailingIncreaseAllowance() public {
+        _failing.safeIncreaseAllowance(address(0), 0);
+    }
 
-  function doFailingDecreaseAllowance() public {
-    _failing.safeDecreaseAllowance(address(0), 0);
-  }
+    function doFailingDecreaseAllowance() public {
+        _failing.safeDecreaseAllowance(address(0), 0);
+    }
 
-  // Using _succeeding
+    // Using _succeeding
 
-  function doSucceedingTransfer() public {
-    _succeeding.safeTransfer(address(0), 0);
-  }
+    function doSucceedingTransfer() public {
+        _succeeding.safeTransfer(address(0), 0);
+    }
 
-  function doSucceedingTransferFrom() public {
-    _succeeding.safeTransferFrom(address(0), address(0), 0);
-  }
+    function doSucceedingTransferFrom() public {
+        _succeeding.safeTransferFrom(address(0), address(0), 0);
+    }
 
-  function doSucceedingApprove(uint256 amount) public {
-    _succeeding.safeApprove(address(0), amount);
-  }
+    function doSucceedingApprove(uint256 amount) public {
+        _succeeding.safeApprove(address(0), amount);
+    }
 
-  function doSucceedingIncreaseAllowance(uint256 amount) public {
-    _succeeding.safeIncreaseAllowance(address(0), amount);
-  }
+    function doSucceedingIncreaseAllowance(uint256 amount) public {
+        _succeeding.safeIncreaseAllowance(address(0), amount);
+    }
 
-  function doSucceedingDecreaseAllowance(uint256 amount) public {
-    _succeeding.safeDecreaseAllowance(address(0), amount);
-  }
+    function doSucceedingDecreaseAllowance(uint256 amount) public {
+        _succeeding.safeDecreaseAllowance(address(0), amount);
+    }
 
-  function setAllowance(uint256 allowance_) public {
-    ERC20SucceedingMock(_succeeding).setAllowance(allowance_);
-  }
+    function setAllowance(uint256 allowance_) public {
+        ERC20SucceedingMock(_succeeding).setAllowance(allowance_);
+    }
 
-  function allowance() public view returns (uint256) {
-    return _succeeding.allowance(address(0), address(0));
-  }
+    function allowance() public view returns (uint256) {
+        return _succeeding.allowance(address(0), address(0));
+    }
 }
diff --git a/contracts/mocks/SafeMathMock.sol b/contracts/mocks/SafeMathMock.sol
index 7ddf17e9f..69ed0c38c 100644
--- a/contracts/mocks/SafeMathMock.sol
+++ b/contracts/mocks/SafeMathMock.sol
@@ -3,24 +3,23 @@ pragma solidity ^0.4.24;
 import "../math/SafeMath.sol";
 
 contract SafeMathMock {
+    function mul(uint256 a, uint256 b) public pure returns (uint256) {
+        return SafeMath.mul(a, b);
+    }
 
-  function mul(uint256 a, uint256 b) public pure returns (uint256) {
-    return SafeMath.mul(a, b);
-  }
+    function div(uint256 a, uint256 b) public pure returns (uint256) {
+        return SafeMath.div(a, b);
+    }
 
-  function div(uint256 a, uint256 b) public pure returns (uint256) {
-    return SafeMath.div(a, b);
-  }
+    function sub(uint256 a, uint256 b) public pure returns (uint256) {
+        return SafeMath.sub(a, b);
+    }
 
-  function sub(uint256 a, uint256 b) public pure returns (uint256) {
-    return SafeMath.sub(a, b);
-  }
+    function add(uint256 a, uint256 b) public pure returns (uint256) {
+        return SafeMath.add(a, b);
+    }
 
-  function add(uint256 a, uint256 b) public pure returns (uint256) {
-    return SafeMath.add(a, b);
-  }
-
-  function mod(uint256 a, uint256 b) public pure returns (uint256) {
-    return SafeMath.mod(a, b);
-  }
+    function mod(uint256 a, uint256 b) public pure returns (uint256) {
+        return SafeMath.mod(a, b);
+    }
 }
diff --git a/contracts/mocks/SecondaryMock.sol b/contracts/mocks/SecondaryMock.sol
index 268c12516..faf88f4e3 100644
--- a/contracts/mocks/SecondaryMock.sol
+++ b/contracts/mocks/SecondaryMock.sol
@@ -3,6 +3,5 @@ pragma solidity ^0.4.24;
 import "../ownership/Secondary.sol";
 
 contract SecondaryMock is Secondary {
-  function onlyPrimaryMock() public view onlyPrimary {
-  }
+    function onlyPrimaryMock() public view onlyPrimary {}
 }
diff --git a/contracts/mocks/SignatureBouncerMock.sol b/contracts/mocks/SignatureBouncerMock.sol
index 85076eae6..21572102a 100644
--- a/contracts/mocks/SignatureBouncerMock.sol
+++ b/contracts/mocks/SignatureBouncerMock.sol
@@ -4,70 +4,25 @@ import "../drafts/SignatureBouncer.sol";
 import "./SignerRoleMock.sol";
 
 contract SignatureBouncerMock is SignatureBouncer, SignerRoleMock {
-  function checkValidSignature(address account, bytes signature)
-    public
-    view
-    returns (bool)
-  {
-    return _isValidSignature(account, signature);
-  }
+    function checkValidSignature(address account, bytes signature) public view returns (bool) {
+        return _isValidSignature(account, signature);
+    }
 
-  function onlyWithValidSignature(bytes signature)
-    public
-    onlyValidSignature(signature)
-    view
-  {
+    function onlyWithValidSignature(bytes signature) public onlyValidSignature(signature) view {}
 
-  }
+    function checkValidSignatureAndMethod(address account, bytes signature) public view returns (bool) {
+        return _isValidSignatureAndMethod(account, signature);
+    }
 
-  function checkValidSignatureAndMethod(address account, bytes signature)
-    public
-    view
-    returns (bool)
-  {
-    return _isValidSignatureAndMethod(account, signature);
-  }
+    function onlyWithValidSignatureAndMethod(bytes signature) public onlyValidSignatureAndMethod(signature) view {}
 
-  function onlyWithValidSignatureAndMethod(bytes signature)
-    public
-    onlyValidSignatureAndMethod(signature)
-    view
-  {
+    function checkValidSignatureAndData(address account, bytes, uint, bytes signature) public view returns (bool) {
+        return _isValidSignatureAndData(account, signature);
+    }
 
-  }
+    function onlyWithValidSignatureAndData(uint, bytes signature) public onlyValidSignatureAndData(signature) view {}
 
-  function checkValidSignatureAndData(
-    address account,
-    bytes,
-    uint,
-    bytes signature
-  )
-    public
-    view
-    returns (bool)
-  {
-    return _isValidSignatureAndData(account, signature);
-  }
+    function theWrongMethod(bytes) public pure {}
 
-  function onlyWithValidSignatureAndData(uint, bytes signature)
-    public
-    onlyValidSignatureAndData(signature)
-    view
-  {
-
-  }
-
-  function theWrongMethod(bytes)
-    public
-    pure
-  {
-
-  }
-
-  function tooShortMsgData()
-    public
-    onlyValidSignatureAndData("")
-    view
-  {
-  }
+    function tooShortMsgData() public onlyValidSignatureAndData("") view {}
 }
diff --git a/contracts/mocks/SignerRoleMock.sol b/contracts/mocks/SignerRoleMock.sol
index faf92db68..7eb3c3475 100644
--- a/contracts/mocks/SignerRoleMock.sol
+++ b/contracts/mocks/SignerRoleMock.sol
@@ -3,15 +3,15 @@ pragma solidity ^0.4.24;
 import "../access/roles/SignerRole.sol";
 
 contract SignerRoleMock is SignerRole {
-  function removeSigner(address account) public {
-    _removeSigner(account);
-  }
+    function removeSigner(address account) public {
+        _removeSigner(account);
+    }
 
-  function onlySignerMock() public view onlySigner {
-  }
+    function onlySignerMock() public view onlySigner {
+    }
 
-  // Causes a compilation error if super._removeSigner is not internal
-  function _removeSigner(address account) internal {
-    super._removeSigner(account);
-  }
+    // Causes a compilation error if super._removeSigner is not internal
+    function _removeSigner(address account) internal {
+        super._removeSigner(account);
+    }
 }
diff --git a/contracts/mocks/TimedCrowdsaleImpl.sol b/contracts/mocks/TimedCrowdsaleImpl.sol
index f16e5eb2a..b826c31e5 100644
--- a/contracts/mocks/TimedCrowdsaleImpl.sol
+++ b/contracts/mocks/TimedCrowdsaleImpl.sol
@@ -4,18 +4,9 @@ import "../token/ERC20/IERC20.sol";
 import "../crowdsale/validation/TimedCrowdsale.sol";
 
 contract TimedCrowdsaleImpl is TimedCrowdsale {
-
-  constructor (
-    uint256 openingTime,
-    uint256 closingTime,
-    uint256 rate,
-    address wallet,
-    IERC20 token
-  )
-    public
-    Crowdsale(rate, wallet, token)
-    TimedCrowdsale(openingTime, closingTime)
-  {
-  }
-
+    constructor (uint256 openingTime, uint256 closingTime, uint256 rate, address wallet, IERC20 token)
+        public
+        Crowdsale(rate, wallet, token)
+        TimedCrowdsale(openingTime, closingTime)
+    {}
 }
diff --git a/contracts/ownership/Ownable.sol b/contracts/ownership/Ownable.sol
index 7b5b72102..5ab46c511 100644
--- a/contracts/ownership/Ownable.sol
+++ b/contracts/ownership/Ownable.sol
@@ -6,70 +6,67 @@ pragma solidity ^0.4.24;
  * functions, this simplifies the implementation of "user permissions".
  */
 contract Ownable {
-  address private _owner;
+    address private _owner;
 
-  event OwnershipTransferred(
-    address indexed previousOwner,
-    address indexed newOwner
-  );
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
 
-  /**
-   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
-   * account.
-   */
-  constructor() internal {
-    _owner = msg.sender;
-    emit OwnershipTransferred(address(0), _owner);
-  }
+    /**
+     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
+     * account.
+     */
+    constructor () internal {
+        _owner = msg.sender;
+        emit OwnershipTransferred(address(0), _owner);
+    }
 
-  /**
-   * @return the address of the owner.
-   */
-  function owner() public view returns(address) {
-    return _owner;
-  }
+    /**
+     * @return the address of the owner.
+     */
+    function owner() public view returns (address) {
+        return _owner;
+    }
 
-  /**
-   * @dev Throws if called by any account other than the owner.
-   */
-  modifier onlyOwner() {
-    require(isOwner());
-    _;
-  }
+    /**
+     * @dev Throws if called by any account other than the owner.
+     */
+    modifier onlyOwner() {
+        require(isOwner());
+        _;
+    }
 
-  /**
-   * @return true if `msg.sender` is the owner of the contract.
-   */
-  function isOwner() public view returns(bool) {
-    return msg.sender == _owner;
-  }
+    /**
+     * @return true if `msg.sender` is the owner of the contract.
+     */
+    function isOwner() public view returns (bool) {
+        return msg.sender == _owner;
+    }
 
-  /**
-   * @dev Allows the current owner to relinquish control of the contract.
-   * @notice Renouncing to ownership will leave the contract without an owner.
-   * It will not be possible to call the functions with the `onlyOwner`
-   * modifier anymore.
-   */
-  function renounceOwnership() public onlyOwner {
-    emit OwnershipTransferred(_owner, address(0));
-    _owner = address(0);
-  }
+    /**
+     * @dev Allows the current owner to relinquish control of the contract.
+     * @notice Renouncing to ownership will leave the contract without an owner.
+     * It will not be possible to call the functions with the `onlyOwner`
+     * modifier anymore.
+     */
+    function renounceOwnership() public onlyOwner {
+        emit OwnershipTransferred(_owner, address(0));
+        _owner = address(0);
+    }
 
-  /**
-   * @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 {
-    _transferOwnership(newOwner);
-  }
+    /**
+     * @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 {
+        _transferOwnership(newOwner);
+    }
 
-  /**
-   * @dev Transfers control of the contract to a newOwner.
-   * @param newOwner The address to transfer ownership to.
-   */
-  function _transferOwnership(address newOwner) internal {
-    require(newOwner != address(0));
-    emit OwnershipTransferred(_owner, newOwner);
-    _owner = newOwner;
-  }
+    /**
+     * @dev Transfers control of the contract to a newOwner.
+     * @param newOwner The address to transfer ownership to.
+     */
+    function _transferOwnership(address newOwner) internal {
+        require(newOwner != address(0));
+        emit OwnershipTransferred(_owner, newOwner);
+        _owner = newOwner;
+    }
 }
diff --git a/contracts/ownership/Secondary.sol b/contracts/ownership/Secondary.sol
index 67d2250d5..e12cf3cb4 100644
--- a/contracts/ownership/Secondary.sol
+++ b/contracts/ownership/Secondary.sol
@@ -5,42 +5,42 @@ pragma solidity ^0.4.24;
  * @dev A Secondary contract can only be used by its primary account (the one that created it)
  */
 contract Secondary {
-  address private _primary;
+    address private _primary;
 
-  event PrimaryTransferred(
-    address recipient
-  );
+    event PrimaryTransferred(
+        address recipient
+    );
 
-  /**
-   * @dev Sets the primary account to the one that is creating the Secondary contract.
-   */
-  constructor() internal {
-    _primary = msg.sender;
-    emit PrimaryTransferred(_primary);
-  }
+    /**
+     * @dev Sets the primary account to the one that is creating the Secondary contract.
+     */
+    constructor () internal {
+        _primary = msg.sender;
+        emit PrimaryTransferred(_primary);
+    }
 
-  /**
-   * @dev Reverts if called from any account other than the primary.
-   */
-  modifier onlyPrimary() {
-    require(msg.sender == _primary);
-    _;
-  }
+    /**
+     * @dev Reverts if called from any account other than the primary.
+     */
+    modifier onlyPrimary() {
+        require(msg.sender == _primary);
+        _;
+    }
 
-  /**
-   * @return the address of the primary.
-   */
-  function primary() public view returns (address) {
-    return _primary;
-  }
-  
-  /**
-   * @dev Transfers contract to a new primary.
-   * @param recipient The address of new primary. 
-   */
-  function transferPrimary(address recipient) public onlyPrimary {
-    require(recipient != address(0));
-    _primary = recipient;
-    emit PrimaryTransferred(_primary);
-  }
+    /**
+     * @return the address of the primary.
+     */
+    function primary() public view returns (address) {
+        return _primary;
+    }
+
+    /**
+     * @dev Transfers contract to a new primary.
+     * @param recipient The address of new primary.
+     */
+    function transferPrimary(address recipient) public onlyPrimary {
+        require(recipient != address(0));
+        _primary = recipient;
+        emit PrimaryTransferred(_primary);
+    }
 }
diff --git a/contracts/payment/PaymentSplitter.sol b/contracts/payment/PaymentSplitter.sol
index 0a1b470ef..0b07e62ba 100644
--- a/contracts/payment/PaymentSplitter.sol
+++ b/contracts/payment/PaymentSplitter.sol
@@ -8,109 +8,105 @@ import "../math/SafeMath.sol";
  * of people and split proportionately to some number of shares they own.
  */
 contract PaymentSplitter {
-  using SafeMath for uint256;
+    using SafeMath for uint256;
 
-  event PayeeAdded(address account, uint256 shares);
-  event PaymentReleased(address to, uint256 amount);
-  event PaymentReceived(address from, uint256 amount);
+    event PayeeAdded(address account, uint256 shares);
+    event PaymentReleased(address to, uint256 amount);
+    event PaymentReceived(address from, uint256 amount);
 
-  uint256 private _totalShares;
-  uint256 private _totalReleased;
+    uint256 private _totalShares;
+    uint256 private _totalReleased;
 
-  mapping(address => uint256) private _shares;
-  mapping(address => uint256) private _released;
-  address[] private _payees;
+    mapping(address => uint256) private _shares;
+    mapping(address => uint256) private _released;
+    address[] private _payees;
 
-  /**
-   * @dev Constructor
-   */
-  constructor(address[] payees, uint256[] shares) public payable {
-    require(payees.length == shares.length);
-    require(payees.length > 0);
+    /**
+     * @dev Constructor
+     */
+    constructor (address[] payees, uint256[] shares) public payable {
+        require(payees.length == shares.length);
+        require(payees.length > 0);
 
-    for (uint256 i = 0; i < payees.length; i++) {
-      _addPayee(payees[i], shares[i]);
+        for (uint256 i = 0; i < payees.length; i++) {
+            _addPayee(payees[i], shares[i]);
+        }
     }
-  }
 
-  /**
-   * @dev payable fallback
-   */
-  function () external payable {
-    emit PaymentReceived(msg.sender, msg.value);
-  }
+    /**
+     * @dev payable fallback
+     */
+    function () external payable {
+        emit PaymentReceived(msg.sender, msg.value);
+    }
 
-  /**
-   * @return the total shares of the contract.
-   */
-  function totalShares() public view returns(uint256) {
-    return _totalShares;
-  }
+    /**
+     * @return the total shares of the contract.
+     */
+    function totalShares() public view returns (uint256) {
+        return _totalShares;
+    }
 
-  /**
-   * @return the total amount already released.
-   */
-  function totalReleased() public view returns(uint256) {
-    return _totalReleased;
-  }
+    /**
+     * @return the total amount already released.
+     */
+    function totalReleased() public view returns (uint256) {
+        return _totalReleased;
+    }
 
-  /**
-   * @return the shares of an account.
-   */
-  function shares(address account) public view returns(uint256) {
-    return _shares[account];
-  }
+    /**
+     * @return the shares of an account.
+     */
+    function shares(address account) public view returns (uint256) {
+        return _shares[account];
+    }
 
-  /**
-   * @return the amount already released to an account.
-   */
-  function released(address account) public view returns(uint256) {
-    return _released[account];
-  }
+    /**
+     * @return the amount already released to an account.
+     */
+    function released(address account) public view returns (uint256) {
+        return _released[account];
+    }
 
-  /**
-   * @return the address of a payee.
-   */
-  function payee(uint256 index) public view returns(address) {
-    return _payees[index];
-  }
+    /**
+     * @return the address of a payee.
+     */
+    function payee(uint256 index) public view returns (address) {
+        return _payees[index];
+    }
 
-  /**
-   * @dev Release one of the payee's proportional payment.
-   * @param account Whose payments will be released.
-   */
-  function release(address account) public {
-    require(_shares[account] > 0);
+    /**
+     * @dev Release one of the payee's proportional payment.
+     * @param account Whose payments will be released.
+     */
+    function release(address account) public {
+        require(_shares[account] > 0);
 
-    uint256 totalReceived = address(this).balance.add(_totalReleased);
-    uint256 payment = totalReceived.mul(
-      _shares[account]).div(
-        _totalShares).sub(
-          _released[account]
-    );
+        uint256 totalReceived = address(this).balance.add(_totalReleased);
+        uint256 payment = totalReceived.mul(_shares[account]).div(_totalShares).sub(_released[account]);
 
-    require(payment != 0);
+        require(payment != 0);
 
-    _released[account] = _released[account].add(payment);
-    _totalReleased = _totalReleased.add(payment);
+        _released[account] = _released[account].add(payment);
+        _totalReleased = _totalReleased.add(payment);
 
-    account.transfer(payment);
-    emit PaymentReleased(account, payment);
-  }
+        account.transfer(payment);
+        emit PaymentReleased(account, payment);
+    }
 
-  /**
-   * @dev Add a new payee to the contract.
-   * @param account The address of the payee to add.
-   * @param shares_ The number of shares owned by the payee.
-   */
-  function _addPayee(address account, uint256 shares_) private {
-    require(account != address(0));
-    require(shares_ > 0);
-    require(_shares[account] == 0);
+    /**
+     * @dev Add a new payee to the contract.
+     * @param account The address of the payee to add.
+     * @param shares_ The number of shares owned by the payee.
+     */
+    function _addPayee(address account, uint256 shares_) private {
+        require(account != address(0));
+        require(shares_ > 0);
+        require(_shares[account] == 0);
 
-    _payees.push(account);
-    _shares[account] = shares_;
-    _totalShares = _totalShares.add(shares_);
-    emit PayeeAdded(account, shares_);
-  }
+        _payees.push(account);
+        _shares[account] = shares_;
+        _totalShares = _totalShares.add(shares_);
+        emit PayeeAdded(account, shares_);
+    }
 }
diff --git a/contracts/payment/PullPayment.sol b/contracts/payment/PullPayment.sol
index f6d7e2c1e..9517638be 100644
--- a/contracts/payment/PullPayment.sol
+++ b/contracts/payment/PullPayment.sol
@@ -8,34 +8,34 @@ import "./escrow/Escrow.sol";
  * contract and use _asyncTransfer instead of send or transfer.
  */
 contract PullPayment {
-  Escrow private _escrow;
+    Escrow private _escrow;
 
-  constructor() internal {
-    _escrow = new Escrow();
-  }
+    constructor () internal {
+        _escrow = new Escrow();
+    }
 
-  /**
-  * @dev Withdraw accumulated balance.
-  * @param payee Whose balance will be withdrawn.
-  */
-  function withdrawPayments(address payee) public {
-    _escrow.withdraw(payee);
-  }
+    /**
+    * @dev Withdraw accumulated balance.
+    * @param payee Whose balance will be withdrawn.
+    */
+    function withdrawPayments(address payee) public {
+        _escrow.withdraw(payee);
+    }
 
-  /**
-  * @dev Returns the credit owed to an address.
-  * @param dest The creditor's address.
-  */
-  function payments(address dest) public view returns (uint256) {
-    return _escrow.depositsOf(dest);
-  }
+    /**
+    * @dev Returns the credit owed to an address.
+    * @param dest The creditor's address.
+    */
+    function payments(address dest) public view returns (uint256) {
+        return _escrow.depositsOf(dest);
+    }
 
-  /**
-  * @dev Called by the payer to store the sent amount as credit to be pulled.
-  * @param dest The destination address of the funds.
-  * @param amount The amount to transfer.
-  */
-  function _asyncTransfer(address dest, uint256 amount) internal {
-    _escrow.deposit.value(amount)(dest);
-  }
+    /**
+    * @dev Called by the payer to store the sent amount as credit to be pulled.
+    * @param dest The destination address of the funds.
+    * @param amount The amount to transfer.
+    */
+    function _asyncTransfer(address dest, uint256 amount) internal {
+        _escrow.deposit.value(amount)(dest);
+    }
 }
diff --git a/contracts/payment/escrow/ConditionalEscrow.sol b/contracts/payment/escrow/ConditionalEscrow.sol
index c3f63ee37..8697b4f93 100644
--- a/contracts/payment/escrow/ConditionalEscrow.sol
+++ b/contracts/payment/escrow/ConditionalEscrow.sol
@@ -8,15 +8,15 @@ import "./Escrow.sol";
  * @dev Intended usage: See Escrow.sol. Same usage guidelines apply here.
  */
 contract ConditionalEscrow is Escrow {
-  /**
-  * @dev Returns whether an address is allowed to withdraw their funds. To be
-  * implemented by derived contracts.
-  * @param payee The destination address of the funds.
-  */
-  function withdrawalAllowed(address payee) public view returns (bool);
+    /**
+    * @dev Returns whether an address is allowed to withdraw their funds. To be
+    * implemented by derived contracts.
+    * @param payee The destination address of the funds.
+    */
+    function withdrawalAllowed(address payee) public view returns (bool);
 
-  function withdraw(address payee) public {
-    require(withdrawalAllowed(payee));
-    super.withdraw(payee);
-  }
+    function withdraw(address payee) public {
+        require(withdrawalAllowed(payee));
+        super.withdraw(payee);
+    }
 }
diff --git a/contracts/payment/escrow/Escrow.sol b/contracts/payment/escrow/Escrow.sol
index b2f2a85ee..088df38ff 100644
--- a/contracts/payment/escrow/Escrow.sol
+++ b/contracts/payment/escrow/Escrow.sol
@@ -16,39 +16,39 @@ import "../../ownership/Secondary.sol";
  * to the escrow's deposit and withdraw.
  */
 contract Escrow is Secondary {
-  using SafeMath for uint256;
+    using SafeMath for uint256;
 
-  event Deposited(address indexed payee, uint256 weiAmount);
-  event Withdrawn(address indexed payee, uint256 weiAmount);
+    event Deposited(address indexed payee, uint256 weiAmount);
+    event Withdrawn(address indexed payee, uint256 weiAmount);
 
-  mapping(address => uint256) private _deposits;
+    mapping(address => uint256) private _deposits;
 
-  function depositsOf(address payee) public view returns (uint256) {
-    return _deposits[payee];
-  }
+    function depositsOf(address payee) public view returns (uint256) {
+        return _deposits[payee];
+    }
 
-  /**
-  * @dev Stores the sent amount as credit to be withdrawn.
-  * @param payee The destination address of the funds.
-  */
-  function deposit(address payee) public onlyPrimary payable {
-    uint256 amount = msg.value;
-    _deposits[payee] = _deposits[payee].add(amount);
+    /**
+    * @dev Stores the sent amount as credit to be withdrawn.
+    * @param payee The destination address of the funds.
+    */
+    function deposit(address payee) public onlyPrimary payable {
+        uint256 amount = msg.value;
+        _deposits[payee] = _deposits[payee].add(amount);
 
-    emit Deposited(payee, amount);
-  }
+        emit Deposited(payee, amount);
+    }
 
-  /**
-  * @dev Withdraw accumulated balance for a payee.
-  * @param payee The address whose funds will be withdrawn and transferred to.
-  */
-  function withdraw(address payee) public onlyPrimary {
-    uint256 payment = _deposits[payee];
+    /**
+    * @dev Withdraw accumulated balance for a payee.
+    * @param payee The address whose funds will be withdrawn and transferred to.
+    */
+    function withdraw(address payee) public onlyPrimary {
+        uint256 payment = _deposits[payee];
 
-    _deposits[payee] = 0;
+        _deposits[payee] = 0;
 
-    payee.transfer(payment);
+        payee.transfer(payment);
 
-    emit Withdrawn(payee, payment);
-  }
+        emit Withdrawn(payee, payment);
+    }
 }
diff --git a/contracts/payment/escrow/RefundEscrow.sol b/contracts/payment/escrow/RefundEscrow.sol
index a776a81c8..67f00e580 100644
--- a/contracts/payment/escrow/RefundEscrow.sol
+++ b/contracts/payment/escrow/RefundEscrow.sol
@@ -14,78 +14,78 @@ import "./ConditionalEscrow.sol";
  * RefundableCrowdsale contract for an example of RefundEscrow’s use.
  */
 contract RefundEscrow is ConditionalEscrow {
-  enum State { Active, Refunding, Closed }
+    enum State { Active, Refunding, Closed }
 
-  event RefundsClosed();
-  event RefundsEnabled();
+    event RefundsClosed();
+    event RefundsEnabled();
 
-  State private _state;
-  address private _beneficiary;
+    State private _state;
+    address private _beneficiary;
 
-  /**
-   * @dev Constructor.
-   * @param beneficiary The beneficiary of the deposits.
-   */
-  constructor(address beneficiary) public {
-    require(beneficiary != address(0));
-    _beneficiary = beneficiary;
-    _state = State.Active;
-  }
+    /**
+     * @dev Constructor.
+     * @param beneficiary The beneficiary of the deposits.
+     */
+    constructor (address beneficiary) public {
+        require(beneficiary != address(0));
+        _beneficiary = beneficiary;
+        _state = State.Active;
+    }
 
-  /**
-   * @return the current state of the escrow.
-   */
-  function state() public view returns (State) {
-    return _state;
-  }
+    /**
+     * @return the current state of the escrow.
+     */
+    function state() public view returns (State) {
+        return _state;
+    }
 
-  /**
-   * @return the beneficiary of the escrow.
-   */
-  function beneficiary() public view returns (address) {
-    return _beneficiary;
-  }
+    /**
+     * @return the beneficiary of the escrow.
+     */
+    function beneficiary() public view returns (address) {
+        return _beneficiary;
+    }
 
-  /**
-   * @dev Stores funds that may later be refunded.
-   * @param refundee The address funds will be sent to if a refund occurs.
-   */
-  function deposit(address refundee) public payable {
-    require(_state == State.Active);
-    super.deposit(refundee);
-  }
+    /**
+     * @dev Stores funds that may later be refunded.
+     * @param refundee The address funds will be sent to if a refund occurs.
+     */
+    function deposit(address refundee) public payable {
+        require(_state == State.Active);
+        super.deposit(refundee);
+    }
 
-  /**
-   * @dev Allows for the beneficiary to withdraw their funds, rejecting
-   * further deposits.
-   */
-  function close() public onlyPrimary {
-    require(_state == State.Active);
-    _state = State.Closed;
-    emit RefundsClosed();
-  }
+    /**
+     * @dev Allows for the beneficiary to withdraw their funds, rejecting
+     * further deposits.
+     */
+    function close() public onlyPrimary {
+        require(_state == State.Active);
+        _state = State.Closed;
+        emit RefundsClosed();
+    }
 
-  /**
-   * @dev Allows for refunds to take place, rejecting further deposits.
-   */
-  function enableRefunds() public onlyPrimary {
-    require(_state == State.Active);
-    _state = State.Refunding;
-    emit RefundsEnabled();
-  }
+    /**
+     * @dev Allows for refunds to take place, rejecting further deposits.
+     */
+    function enableRefunds() public onlyPrimary {
+        require(_state == State.Active);
+        _state = State.Refunding;
+        emit RefundsEnabled();
+    }
 
-  /**
-   * @dev Withdraws the beneficiary's funds.
-   */
-  function beneficiaryWithdraw() public {
-    require(_state == State.Closed);
-    _beneficiary.transfer(address(this).balance);
-  }
+    /**
+     * @dev Withdraws the beneficiary's funds.
+     */
+    function beneficiaryWithdraw() public {
+        require(_state == State.Closed);
+        _beneficiary.transfer(address(this).balance);
+    }
 
-  /**
-   * @dev Returns whether refundees can withdraw their deposits (be refunded).
-   */
-  function withdrawalAllowed(address payee) public view returns (bool) {
-    return _state == State.Refunding;
-  }
+    /**
+     * @dev Returns whether refundees can withdraw their deposits (be refunded).
+     */
+    function withdrawalAllowed(address payee) public view returns (bool) {
+        return _state == State.Refunding;
+    }
 }
diff --git a/contracts/token/ERC20/ERC20.sol b/contracts/token/ERC20/ERC20.sol
index 5c550539f..abb43b74d 100644
--- a/contracts/token/ERC20/ERC20.sol
+++ b/contracts/token/ERC20/ERC20.sol
@@ -11,196 +11,167 @@ import "../../math/SafeMath.sol";
  * Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
  */
 contract ERC20 is IERC20 {
-  using SafeMath for uint256;
+    using SafeMath for uint256;
 
-  mapping (address => uint256) private _balances;
+    mapping (address => uint256) private _balances;
 
-  mapping (address => mapping (address => uint256)) private _allowed;
+    mapping (address => mapping (address => uint256)) private _allowed;
 
-  uint256 private _totalSupply;
+    uint256 private _totalSupply;
 
-  /**
-  * @dev Total number of tokens in existence
-  */
-  function totalSupply() public view returns (uint256) {
-    return _totalSupply;
-  }
+    /**
+    * @dev Total number of tokens in existence
+    */
+    function totalSupply() public view returns (uint256) {
+        return _totalSupply;
+    }
 
-  /**
-  * @dev Gets the balance of the specified address.
-  * @param owner The address to query the balance of.
-  * @return An uint256 representing the amount owned by the passed address.
-  */
-  function balanceOf(address owner) public view returns (uint256) {
-    return _balances[owner];
-  }
+    /**
+    * @dev Gets the balance of the specified address.
+    * @param owner The address to query the balance of.
+    * @return An uint256 representing the amount owned by the passed address.
+    */
+    function balanceOf(address owner) public view returns (uint256) {
+        return _balances[owner];
+    }
 
-  /**
-   * @dev Function to check the amount of tokens that an owner allowed to a spender.
-   * @param owner address The address which owns the funds.
-   * @param spender address The address which will spend the funds.
-   * @return A uint256 specifying the amount of tokens still available for the spender.
-   */
-  function allowance(
-    address owner,
-    address spender
-   )
-    public
-    view
-    returns (uint256)
-  {
-    return _allowed[owner][spender];
-  }
+    /**
+     * @dev Function to check the amount of tokens that an owner allowed to a spender.
+     * @param owner address The address which owns the funds.
+     * @param spender address The address which will spend the funds.
+     * @return A uint256 specifying the amount of tokens still available for the spender.
+     */
+    function allowance(address owner, address spender) public view returns (uint256) {
+        return _allowed[owner][spender];
+    }
 
-  /**
-  * @dev Transfer token for a specified address
-  * @param to The address to transfer to.
-  * @param value The amount to be transferred.
-  */
-  function transfer(address to, uint256 value) public returns (bool) {
-    _transfer(msg.sender, to, value);
-    return true;
-  }
+    /**
+    * @dev Transfer token for a specified address
+    * @param to The address to transfer to.
+    * @param value The amount to be transferred.
+    */
+    function transfer(address to, uint256 value) public returns (bool) {
+        _transfer(msg.sender, to, value);
+        return true;
+    }
 
-  /**
-   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
-   * Beware that changing an allowance with this method brings the risk that someone may use both the old
-   * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
-   * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
-   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
-   * @param spender The address which will spend the funds.
-   * @param value The amount of tokens to be spent.
-   */
-  function approve(address spender, uint256 value) public returns (bool) {
-    require(spender != address(0));
+    /**
+     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
+     * Beware that changing an allowance with this method brings the risk that someone may use both the old
+     * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
+     * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
+     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+     * @param spender The address which will spend the funds.
+     * @param value The amount of tokens to be spent.
+     */
+    function approve(address spender, uint256 value) public returns (bool) {
+        require(spender != address(0));
 
-    _allowed[msg.sender][spender] = value;
-    emit Approval(msg.sender, spender, value);
-    return true;
-  }
+        _allowed[msg.sender][spender] = value;
+        emit Approval(msg.sender, spender, value);
+        return true;
+    }
 
-  /**
-   * @dev Transfer tokens from one address to another
-   * @param from address The address which you want to send tokens from
-   * @param to address The address which you want to transfer to
-   * @param value uint256 the amount of tokens to be transferred
-   */
-  function transferFrom(
-    address from,
-    address to,
-    uint256 value
-  )
-    public
-    returns (bool)
-  {
-    _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
-    _transfer(from, to, value);
-    return true;
-  }
+    /**
+     * @dev Transfer tokens from one address to another
+     * @param from address The address which you want to send tokens from
+     * @param to address The address which you want to transfer to
+     * @param value uint256 the amount of tokens to be transferred
+     */
+    function transferFrom(address from, address to, uint256 value) public returns (bool) {
+        _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
+        _transfer(from, to, value);
+        return true;
+    }
 
-  /**
-   * @dev Increase the amount of tokens that an owner allowed to a spender.
-   * approve should be called when allowed_[_spender] == 0. To increment
-   * allowed value is better to use this function to avoid 2 calls (and wait until
-   * the first transaction is mined)
-   * From MonolithDAO Token.sol
-   * @param spender The address which will spend the funds.
-   * @param addedValue The amount of tokens to increase the allowance by.
-   */
-  function increaseAllowance(
-    address spender,
-    uint256 addedValue
-  )
-    public
-    returns (bool)
-  {
-    require(spender != address(0));
+    /**
+     * @dev Increase the amount of tokens that an owner allowed to a spender.
+     * approve should be called when allowed_[_spender] == 0. To increment
+     * allowed value is better to use this function to avoid 2 calls (and wait until
+     * the first transaction is mined)
+     * From MonolithDAO Token.sol
+     * @param spender The address which will spend the funds.
+     * @param addedValue The amount of tokens to increase the allowance by.
+     */
+    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
+        require(spender != address(0));
 
-    _allowed[msg.sender][spender] = (
-      _allowed[msg.sender][spender].add(addedValue));
-    emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
-    return true;
-  }
+        _allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
+        emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
+        return true;
+    }
 
-  /**
-   * @dev Decrease the amount of tokens that an owner allowed to a spender.
-   * approve should be called when allowed_[_spender] == 0. To decrement
-   * allowed value is better to use this function to avoid 2 calls (and wait until
-   * the first transaction is mined)
-   * From MonolithDAO Token.sol
-   * @param spender The address which will spend the funds.
-   * @param subtractedValue The amount of tokens to decrease the allowance by.
-   */
-  function decreaseAllowance(
-    address spender,
-    uint256 subtractedValue
-  )
-    public
-    returns (bool)
-  {
-    require(spender != address(0));
+    /**
+     * @dev Decrease the amount of tokens that an owner allowed to a spender.
+     * approve should be called when allowed_[_spender] == 0. To decrement
+     * allowed value is better to use this function to avoid 2 calls (and wait until
+     * the first transaction is mined)
+     * From MonolithDAO Token.sol
+     * @param spender The address which will spend the funds.
+     * @param subtractedValue The amount of tokens to decrease the allowance by.
+     */
+    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
+        require(spender != address(0));
 
-    _allowed[msg.sender][spender] = (
-      _allowed[msg.sender][spender].sub(subtractedValue));
-    emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
-    return true;
-  }
+        _allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
+        emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
+        return true;
+    }
 
-  /**
-  * @dev Transfer token for a specified addresses
-  * @param from The address to transfer from.
-  * @param to The address to transfer to.
-  * @param value The amount to be transferred.
-  */
-  function _transfer(address from, address to, uint256 value) internal {
-    require(to != address(0));
+    /**
+    * @dev Transfer token for a specified addresses
+    * @param from The address to transfer from.
+    * @param to The address to transfer to.
+    * @param value The amount to be transferred.
+    */
+    function _transfer(address from, address to, uint256 value) internal {
+        require(to != address(0));
 
-    _balances[from] = _balances[from].sub(value);
-    _balances[to] = _balances[to].add(value);
-    emit Transfer(from, to, value);
-  }
+        _balances[from] = _balances[from].sub(value);
+        _balances[to] = _balances[to].add(value);
+        emit Transfer(from, to, value);
+    }
 
-  /**
-   * @dev Internal function that mints an amount of the token and assigns it to
-   * an account. This encapsulates the modification of balances such that the
-   * proper events are emitted.
-   * @param account The account that will receive the created tokens.
-   * @param value The amount that will be created.
-   */
-  function _mint(address account, uint256 value) internal {
-    require(account != address(0));
+    /**
+     * @dev Internal function that mints an amount of the token and assigns it to
+     * an account. This encapsulates the modification of balances such that the
+     * proper events are emitted.
+     * @param account The account that will receive the created tokens.
+     * @param value The amount that will be created.
+     */
+    function _mint(address account, uint256 value) internal {
+        require(account != address(0));
 
-    _totalSupply = _totalSupply.add(value);
-    _balances[account] = _balances[account].add(value);
-    emit Transfer(address(0), account, value);
-  }
+        _totalSupply = _totalSupply.add(value);
+        _balances[account] = _balances[account].add(value);
+        emit Transfer(address(0), account, value);
+    }
 
-  /**
-   * @dev Internal function that burns an amount of the token of a given
-   * account.
-   * @param account The account whose tokens will be burnt.
-   * @param value The amount that will be burnt.
-   */
-  function _burn(address account, uint256 value) internal {
-    require(account != address(0));
+    /**
+     * @dev Internal function that burns an amount of the token of a given
+     * account.
+     * @param account The account whose tokens will be burnt.
+     * @param value The amount that will be burnt.
+     */
+    function _burn(address account, uint256 value) internal {
+        require(account != address(0));
 
-    _totalSupply = _totalSupply.sub(value);
-    _balances[account] = _balances[account].sub(value);
-    emit Transfer(account, address(0), value);
-  }
+        _totalSupply = _totalSupply.sub(value);
+        _balances[account] = _balances[account].sub(value);
+        emit Transfer(account, address(0), value);
+    }
 
-  /**
-   * @dev Internal function that burns an amount of the token of a given
-   * account, deducting from the sender's allowance for said account. Uses the
-   * internal burn function.
-   * @param account The account whose tokens will be burnt.
-   * @param value The amount that will be burnt.
-   */
-  function _burnFrom(address account, uint256 value) internal {
-    // Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
-    // this function needs to emit an event with the updated approval.
-    _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
-      value);
-    _burn(account, value);
-  }
+    /**
+     * @dev Internal function that burns an amount of the token of a given
+     * account, deducting from the sender's allowance for said account. Uses the
+     * internal burn function.
+     * @param account The account whose tokens will be burnt.
+     * @param value The amount that will be burnt.
+     */
+    function _burnFrom(address account, uint256 value) internal {
+        // Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
+        // this function needs to emit an event with the updated approval.
+        _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
+        _burn(account, value);
+    }
 }
diff --git a/contracts/token/ERC20/ERC20Burnable.sol b/contracts/token/ERC20/ERC20Burnable.sol
index ba4a2ccbe..9f1120016 100644
--- a/contracts/token/ERC20/ERC20Burnable.sol
+++ b/contracts/token/ERC20/ERC20Burnable.sol
@@ -7,21 +7,20 @@ import "./ERC20.sol";
  * @dev Token that can be irreversibly burned (destroyed).
  */
 contract ERC20Burnable is ERC20 {
+    /**
+     * @dev Burns a specific amount of tokens.
+     * @param value The amount of token to be burned.
+     */
+    function burn(uint256 value) public {
+        _burn(msg.sender, value);
+    }
 
-  /**
-   * @dev Burns a specific amount of tokens.
-   * @param value The amount of token to be burned.
-   */
-  function burn(uint256 value) public {
-    _burn(msg.sender, value);
-  }
-
-  /**
-   * @dev Burns a specific amount of tokens from the target address and decrements allowance
-   * @param from address The address which you want to send tokens from
-   * @param value uint256 The amount of token to be burned
-   */
-  function burnFrom(address from, uint256 value) public {
-    _burnFrom(from, value);
-  }
+    /**
+     * @dev Burns a specific amount of tokens from the target address and decrements allowance
+     * @param from address The address which you want to send tokens from
+     * @param value uint256 The amount of token to be burned
+     */
+    function burnFrom(address from, uint256 value) public {
+        _burnFrom(from, value);
+    }
 }
diff --git a/contracts/token/ERC20/ERC20Capped.sol b/contracts/token/ERC20/ERC20Capped.sol
index a80dd491c..2d6c35326 100644
--- a/contracts/token/ERC20/ERC20Capped.sol
+++ b/contracts/token/ERC20/ERC20Capped.sol
@@ -7,25 +7,22 @@ import "./ERC20Mintable.sol";
  * @dev Mintable token with a token cap.
  */
 contract ERC20Capped is ERC20Mintable {
+    uint256 private _cap;
 
-  uint256 private _cap;
+    constructor (uint256 cap) public {
+        require(cap > 0);
+        _cap = cap;
+    }
 
-  constructor(uint256 cap)
-    public
-  {
-    require(cap > 0);
-    _cap = cap;
-  }
+    /**
+     * @return the cap for the token minting.
+     */
+    function cap() public view returns (uint256) {
+        return _cap;
+    }
 
-  /**
-   * @return the cap for the token minting.
-   */
-  function cap() public view returns(uint256) {
-    return _cap;
-  }
-
-  function _mint(address account, uint256 value) internal {
-    require(totalSupply().add(value) <= _cap);
-    super._mint(account, value);
-  }
+    function _mint(address account, uint256 value) internal {
+        require(totalSupply().add(value) <= _cap);
+        super._mint(account, value);
+    }
 }
diff --git a/contracts/token/ERC20/ERC20Detailed.sol b/contracts/token/ERC20/ERC20Detailed.sol
index 706dbfc46..02f1648da 100644
--- a/contracts/token/ERC20/ERC20Detailed.sol
+++ b/contracts/token/ERC20/ERC20Detailed.sol
@@ -9,34 +9,34 @@ import "./IERC20.sol";
  * just as on Ethereum all the operations are done in wei.
  */
 contract ERC20Detailed is IERC20 {
-  string private _name;
-  string private _symbol;
-  uint8 private _decimals;
+    string private _name;
+    string private _symbol;
+    uint8 private _decimals;
 
-  constructor(string name, string symbol, uint8 decimals) public {
-    _name = name;
-    _symbol = symbol;
-    _decimals = decimals;
-  }
+    constructor (string name, string symbol, uint8 decimals) public {
+        _name = name;
+        _symbol = symbol;
+        _decimals = decimals;
+    }
 
-  /**
-   * @return the name of the token.
-   */
-  function name() public view returns(string) {
-    return _name;
-  }
+    /**
+     * @return the name of the token.
+     */
+    function name() public view returns (string) {
+        return _name;
+    }
 
-  /**
-   * @return the symbol of the token.
-   */
-  function symbol() public view returns(string) {
-    return _symbol;
-  }
+    /**
+     * @return the symbol of the token.
+     */
+    function symbol() public view returns (string) {
+        return _symbol;
+    }
 
-  /**
-   * @return the number of decimals of the token.
-   */
-  function decimals() public view returns(uint8) {
-    return _decimals;
-  }
+    /**
+     * @return the number of decimals of the token.
+     */
+    function decimals() public view returns (uint8) {
+        return _decimals;
+    }
 }
diff --git a/contracts/token/ERC20/ERC20Mintable.sol b/contracts/token/ERC20/ERC20Mintable.sol
index eb01f06e7..ec30caa48 100644
--- a/contracts/token/ERC20/ERC20Mintable.sol
+++ b/contracts/token/ERC20/ERC20Mintable.sol
@@ -8,21 +8,14 @@ import "../../access/roles/MinterRole.sol";
  * @dev ERC20 minting logic
  */
 contract ERC20Mintable is ERC20, MinterRole {
-  /**
-   * @dev Function to mint tokens
-   * @param to The address that will receive the minted tokens.
-   * @param value The amount of tokens to mint.
-   * @return A boolean that indicates if the operation was successful.
-   */
-  function mint(
-    address to,
-    uint256 value
-  )
-    public
-    onlyMinter
-    returns (bool)
-  {
-    _mint(to, value);
-    return true;
-  }
+    /**
+     * @dev Function to mint tokens
+     * @param to The address that will receive the minted tokens.
+     * @param value The amount of tokens to mint.
+     * @return A boolean that indicates if the operation was successful.
+     */
+    function mint(address to, uint256 value) public onlyMinter returns (bool) {
+        _mint(to, value);
+        return true;
+    }
 }
diff --git a/contracts/token/ERC20/ERC20Pausable.sol b/contracts/token/ERC20/ERC20Pausable.sol
index 8e6aa881f..b3947d589 100644
--- a/contracts/token/ERC20/ERC20Pausable.sol
+++ b/contracts/token/ERC20/ERC20Pausable.sol
@@ -8,60 +8,23 @@ import "../../lifecycle/Pausable.sol";
  * @dev ERC20 modified with pausable transfers.
  **/
 contract ERC20Pausable is ERC20, Pausable {
+    function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
+        return super.transfer(to, value);
+    }
 
-  function transfer(
-    address to,
-    uint256 value
-  )
-    public
-    whenNotPaused
-    returns (bool)
-  {
-    return super.transfer(to, value);
-  }
+    function transferFrom(address from,address to, uint256 value) public whenNotPaused returns (bool) {
+        return super.transferFrom(from, to, value);
+    }
 
-  function transferFrom(
-    address from,
-    address to,
-    uint256 value
-  )
-    public
-    whenNotPaused
-    returns (bool)
-  {
-    return super.transferFrom(from, to, value);
-  }
+    function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
+        return super.approve(spender, value);
+    }
 
-  function approve(
-    address spender,
-    uint256 value
-  )
-    public
-    whenNotPaused
-    returns (bool)
-  {
-    return super.approve(spender, value);
-  }
+    function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool success) {
+        return super.increaseAllowance(spender, addedValue);
+    }
 
-  function increaseAllowance(
-    address spender,
-    uint addedValue
-  )
-    public
-    whenNotPaused
-    returns (bool success)
-  {
-    return super.increaseAllowance(spender, addedValue);
-  }
-
-  function decreaseAllowance(
-    address spender,
-    uint subtractedValue
-  )
-    public
-    whenNotPaused
-    returns (bool success)
-  {
-    return super.decreaseAllowance(spender, subtractedValue);
-  }
+    function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool success) {
+        return super.decreaseAllowance(spender, subtractedValue);
+    }
 }
diff --git a/contracts/token/ERC20/IERC20.sol b/contracts/token/ERC20/IERC20.sol
index 37e5a447c..7c44280f0 100644
--- a/contracts/token/ERC20/IERC20.sol
+++ b/contracts/token/ERC20/IERC20.sol
@@ -5,30 +5,19 @@ pragma solidity ^0.4.24;
  * @dev see https://github.com/ethereum/EIPs/issues/20
  */
 interface IERC20 {
-  function totalSupply() external view returns (uint256);
+    function totalSupply() external view returns (uint256);
 
-  function balanceOf(address who) external view returns (uint256);
+    function balanceOf(address who) external view returns (uint256);
 
-  function allowance(address owner, address spender)
-    external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
 
-  function transfer(address to, uint256 value) external returns (bool);
+    function transfer(address to, uint256 value) external returns (bool);
 
-  function approve(address spender, uint256 value)
-    external returns (bool);
+    function approve(address spender, uint256 value) external returns (bool);
 
-  function transferFrom(address from, address to, uint256 value)
-    external returns (bool);
+    function transferFrom(address from, address to, uint256 value) external returns (bool);
 
-  event Transfer(
-    address indexed from,
-    address indexed to,
-    uint256 value
-  );
+    event Transfer(address indexed from, address indexed to, uint256 value);
 
-  event Approval(
-    address indexed owner,
-    address indexed spender,
-    uint256 value
-  );
+    event Approval(address indexed owner, address indexed spender, uint256 value);
 }
diff --git a/contracts/token/ERC20/SafeERC20.sol b/contracts/token/ERC20/SafeERC20.sol
index 2774afa08..adb217e0b 100644
--- a/contracts/token/ERC20/SafeERC20.sol
+++ b/contracts/token/ERC20/SafeERC20.sol
@@ -10,63 +10,31 @@ import "../../math/SafeMath.sol";
  * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
  */
 library SafeERC20 {
+    using SafeMath for uint256;
 
-  using SafeMath for uint256;
+    function safeTransfer(IERC20 token, address to, uint256 value) internal {
+        require(token.transfer(to, value));
+    }
 
-  function safeTransfer(
-    IERC20 token,
-    address to,
-    uint256 value
-  )
-    internal
-  {
-    require(token.transfer(to, value));
-  }
+    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
+        require(token.transferFrom(from, to, value));
+    }
 
-  function safeTransferFrom(
-    IERC20 token,
-    address from,
-    address to,
-    uint256 value
-  )
-    internal
-  {
-    require(token.transferFrom(from, to, value));
-  }
+    function safeApprove(IERC20 token, address spender, uint256 value) internal {
+        // safeApprove should only be called when setting an initial allowance,
+        // or when resetting it to zero. To increase and decrease it, use
+        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
+        require((value == 0) || (token.allowance(msg.sender, spender) == 0));
+        require(token.approve(spender, value));
+    }
 
-  function safeApprove(
-    IERC20 token,
-    address spender,
-    uint256 value
-  )
-    internal
-  {
-    // safeApprove should only be called when setting an initial allowance, 
-    // or when resetting it to zero. To increase and decrease it, use 
-    // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
-    require((value == 0) || (token.allowance(msg.sender, spender) == 0));
-    require(token.approve(spender, value));
-  }
+    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
+        uint256 newAllowance = token.allowance(address(this), spender).add(value);
+        require(token.approve(spender, newAllowance));
+    }
 
-  function safeIncreaseAllowance(
-    IERC20 token,
-    address spender,
-    uint256 value
-  )
-    internal
-  {
-    uint256 newAllowance = token.allowance(address(this), spender).add(value);
-    require(token.approve(spender, newAllowance));
-  }
-
-  function safeDecreaseAllowance(
-    IERC20 token,
-    address spender,
-    uint256 value
-  )
-    internal
-  {
-    uint256 newAllowance = token.allowance(address(this), spender).sub(value);
-    require(token.approve(spender, newAllowance));
-  }
+    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
+        uint256 newAllowance = token.allowance(address(this), spender).sub(value);
+        require(token.approve(spender, newAllowance));
+    }
 }
diff --git a/contracts/token/ERC20/TokenTimelock.sol b/contracts/token/ERC20/TokenTimelock.sol
index 55903482b..a69680507 100644
--- a/contracts/token/ERC20/TokenTimelock.sol
+++ b/contracts/token/ERC20/TokenTimelock.sol
@@ -8,62 +8,56 @@ import "./SafeERC20.sol";
  * beneficiary to extract the tokens after a given release time
  */
 contract TokenTimelock {
-  using SafeERC20 for IERC20;
+    using SafeERC20 for IERC20;
 
-  // ERC20 basic token contract being held
-  IERC20 private _token;
+    // ERC20 basic token contract being held
+    IERC20 private _token;
 
-  // beneficiary of tokens after they are released
-  address private _beneficiary;
+    // beneficiary of tokens after they are released
+    address private _beneficiary;
 
-  // timestamp when token release is enabled
-  uint256 private _releaseTime;
+    // timestamp when token release is enabled
+    uint256 private _releaseTime;
 
-  constructor(
-    IERC20 token,
-    address beneficiary,
-    uint256 releaseTime
-  )
-    public
-  {
-    // solium-disable-next-line security/no-block-members
-    require(releaseTime > block.timestamp);
-    _token = token;
-    _beneficiary = beneficiary;
-    _releaseTime = releaseTime;
-  }
+    constructor (IERC20 token, address beneficiary, uint256 releaseTime) public {
+        // solium-disable-next-line security/no-block-members
+        require(releaseTime > block.timestamp);
+        _token = token;
+        _beneficiary = beneficiary;
+        _releaseTime = releaseTime;
+    }
 
-  /**
-   * @return the token being held.
-   */
-  function token() public view returns(IERC20) {
-    return _token;
-  }
+    /**
+     * @return the token being held.
+     */
+    function token() public view returns (IERC20) {
+        return _token;
+    }
 
-  /**
-   * @return the beneficiary of the tokens.
-   */
-  function beneficiary() public view returns(address) {
-    return _beneficiary;
-  }
+    /**
+     * @return the beneficiary of the tokens.
+     */
+    function beneficiary() public view returns (address) {
+        return _beneficiary;
+    }
 
-  /**
-   * @return the time when the tokens are released.
-   */
-  function releaseTime() public view returns(uint256) {
-    return _releaseTime;
-  }
+    /**
+     * @return the time when the tokens are released.
+     */
+    function releaseTime() public view returns (uint256) {
+        return _releaseTime;
+    }
 
-  /**
-   * @notice Transfers tokens held by timelock to beneficiary.
-   */
-  function release() public {
-    // solium-disable-next-line security/no-block-members
-    require(block.timestamp >= _releaseTime);
+    /**
+     * @notice Transfers tokens held by timelock to beneficiary.
+     */
+    function release() public {
+        // solium-disable-next-line security/no-block-members
+        require(block.timestamp >= _releaseTime);
 
-    uint256 amount = _token.balanceOf(address(this));
-    require(amount > 0);
+        uint256 amount = _token.balanceOf(address(this));
+        require(amount > 0);
 
-    _token.safeTransfer(_beneficiary, amount);
-  }
+        _token.safeTransfer(_beneficiary, amount);
+    }
 }
diff --git a/contracts/token/ERC721/ERC721.sol b/contracts/token/ERC721/ERC721.sol
index ec0763b96..d64c97b32 100644
--- a/contracts/token/ERC721/ERC721.sol
+++ b/contracts/token/ERC721/ERC721.sol
@@ -11,320 +11,272 @@ import "../../introspection/ERC165.sol";
  * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
  */
 contract ERC721 is ERC165, IERC721 {
+    using SafeMath for uint256;
+    using Address for address;
 
-  using SafeMath for uint256;
-  using Address for address;
+    // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
+    // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
+    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
 
-  // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
-  // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
-  bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
+    // Mapping from token ID to owner
+    mapping (uint256 => address) private _tokenOwner;
 
-  // Mapping from token ID to owner
-  mapping (uint256 => address) private _tokenOwner;
+    // Mapping from token ID to approved address
+    mapping (uint256 => address) private _tokenApprovals;
 
-  // Mapping from token ID to approved address
-  mapping (uint256 => address) private _tokenApprovals;
+    // Mapping from owner to number of owned token
+    mapping (address => uint256) private _ownedTokensCount;
 
-  // Mapping from owner to number of owned token
-  mapping (address => uint256) private _ownedTokensCount;
+    // Mapping from owner to operator approvals
+    mapping (address => mapping (address => bool)) private _operatorApprovals;
 
-  // Mapping from owner to operator approvals
-  mapping (address => mapping (address => bool)) private _operatorApprovals;
+    bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd;
+    /*
+     * 0x80ac58cd ===
+     *     bytes4(keccak256('balanceOf(address)')) ^
+     *     bytes4(keccak256('ownerOf(uint256)')) ^
+     *     bytes4(keccak256('approve(address,uint256)')) ^
+     *     bytes4(keccak256('getApproved(uint256)')) ^
+     *     bytes4(keccak256('setApprovalForAll(address,bool)')) ^
+     *     bytes4(keccak256('isApprovedForAll(address,address)')) ^
+     *     bytes4(keccak256('transferFrom(address,address,uint256)')) ^
+     *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) ^
+     *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)'))
+     */
 
-  bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd;
-  /*
-   * 0x80ac58cd ===
-   *   bytes4(keccak256('balanceOf(address)')) ^
-   *   bytes4(keccak256('ownerOf(uint256)')) ^
-   *   bytes4(keccak256('approve(address,uint256)')) ^
-   *   bytes4(keccak256('getApproved(uint256)')) ^
-   *   bytes4(keccak256('setApprovalForAll(address,bool)')) ^
-   *   bytes4(keccak256('isApprovedForAll(address,address)')) ^
-   *   bytes4(keccak256('transferFrom(address,address,uint256)')) ^
-   *   bytes4(keccak256('safeTransferFrom(address,address,uint256)')) ^
-   *   bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)'))
-   */
-
-  constructor()
-    public
-  {
-    // register the supported interfaces to conform to ERC721 via ERC165
-    _registerInterface(_InterfaceId_ERC721);
-  }
-
-  /**
-   * @dev Gets the balance of the specified address
-   * @param owner address to query the balance of
-   * @return uint256 representing the amount owned by the passed address
-   */
-  function balanceOf(address owner) public view returns (uint256) {
-    require(owner != address(0));
-    return _ownedTokensCount[owner];
-  }
-
-  /**
-   * @dev Gets the owner of the specified token ID
-   * @param tokenId uint256 ID of the token to query the owner of
-   * @return owner address currently marked as the owner of the given token ID
-   */
-  function ownerOf(uint256 tokenId) public view returns (address) {
-    address owner = _tokenOwner[tokenId];
-    require(owner != address(0));
-    return owner;
-  }
-
-  /**
-   * @dev Approves another address to transfer the given token ID
-   * The zero address indicates there is no approved address.
-   * There can only be one approved address per token at a given time.
-   * Can only be called by the token owner or an approved operator.
-   * @param to address to be approved for the given token ID
-   * @param tokenId uint256 ID of the token to be approved
-   */
-  function approve(address to, uint256 tokenId) public {
-    address owner = ownerOf(tokenId);
-    require(to != owner);
-    require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
-
-    _tokenApprovals[tokenId] = to;
-    emit Approval(owner, to, tokenId);
-  }
-
-  /**
-   * @dev Gets the approved address for a token ID, or zero if no address set
-   * Reverts if the token ID does not exist.
-   * @param tokenId uint256 ID of the token to query the approval of
-   * @return address currently approved for the given token ID
-   */
-  function getApproved(uint256 tokenId) public view returns (address) {
-    require(_exists(tokenId));
-    return _tokenApprovals[tokenId];
-  }
-
-  /**
-   * @dev Sets or unsets the approval of a given operator
-   * An operator is allowed to transfer all tokens of the sender on their behalf
-   * @param to operator address to set the approval
-   * @param approved representing the status of the approval to be set
-   */
-  function setApprovalForAll(address to, bool approved) public {
-    require(to != msg.sender);
-    _operatorApprovals[msg.sender][to] = approved;
-    emit ApprovalForAll(msg.sender, to, approved);
-  }
-
-  /**
-   * @dev Tells whether an operator is approved by a given owner
-   * @param owner owner address which you want to query the approval of
-   * @param operator operator address which you want to query the approval of
-   * @return bool whether the given operator is approved by the given owner
-   */
-  function isApprovedForAll(
-    address owner,
-    address operator
-  )
-    public
-    view
-    returns (bool)
-  {
-    return _operatorApprovals[owner][operator];
-  }
-
-  /**
-   * @dev Transfers the ownership of a given token ID to another address
-   * Usage of this method is discouraged, use `safeTransferFrom` whenever possible
-   * Requires the msg sender to be the owner, approved, or operator
-   * @param from current owner of the token
-   * @param to address to receive the ownership of the given token ID
-   * @param tokenId uint256 ID of the token to be transferred
-  */
-  function transferFrom(
-    address from,
-    address to,
-    uint256 tokenId
-  )
-    public
-  {
-    require(_isApprovedOrOwner(msg.sender, tokenId));
-    require(to != address(0));
-
-    _clearApproval(from, tokenId);
-    _removeTokenFrom(from, tokenId);
-    _addTokenTo(to, tokenId);
-
-    emit Transfer(from, to, tokenId);
-  }
-
-  /**
-   * @dev Safely transfers the ownership of a given token ID to another address
-   * If the target address is a contract, it must implement `onERC721Received`,
-   * which is called upon a safe transfer, and return the magic value
-   * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
-   * the transfer is reverted.
-   *
-   * Requires the msg sender to be the owner, approved, or operator
-   * @param from current owner of the token
-   * @param to address to receive the ownership of the given token ID
-   * @param tokenId uint256 ID of the token to be transferred
-  */
-  function safeTransferFrom(
-    address from,
-    address to,
-    uint256 tokenId
-  )
-    public
-  {
-    // solium-disable-next-line arg-overflow
-    safeTransferFrom(from, to, tokenId, "");
-  }
-
-  /**
-   * @dev Safely transfers the ownership of a given token ID to another address
-   * If the target address is a contract, it must implement `onERC721Received`,
-   * which is called upon a safe transfer, and return the magic value
-   * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
-   * the transfer is reverted.
-   * Requires the msg sender to be the owner, approved, or operator
-   * @param from current owner of the token
-   * @param to address to receive the ownership of the given token ID
-   * @param tokenId uint256 ID of the token to be transferred
-   * @param _data bytes data to send along with a safe transfer check
-   */
-  function safeTransferFrom(
-    address from,
-    address to,
-    uint256 tokenId,
-    bytes _data
-  )
-    public
-  {
-    transferFrom(from, to, tokenId);
-    // solium-disable-next-line arg-overflow
-    require(_checkOnERC721Received(from, to, tokenId, _data));
-  }
-
-  /**
-   * @dev Returns whether the specified token exists
-   * @param tokenId uint256 ID of the token to query the existence of
-   * @return whether the token exists
-   */
-  function _exists(uint256 tokenId) internal view returns (bool) {
-    address owner = _tokenOwner[tokenId];
-    return owner != address(0);
-  }
-
-  /**
-   * @dev Returns whether the given spender can transfer a given token ID
-   * @param spender address of the spender to query
-   * @param tokenId uint256 ID of the token to be transferred
-   * @return bool whether the msg.sender is approved for the given token ID,
-   *  is an operator of the owner, or is the owner of the token
-   */
-  function _isApprovedOrOwner(
-    address spender,
-    uint256 tokenId
-  )
-    internal
-    view
-    returns (bool)
-  {
-    address owner = ownerOf(tokenId);
-    // Disable solium check because of
-    // https://github.com/duaraghav8/Solium/issues/175
-    // solium-disable-next-line operator-whitespace
-    return (
-      spender == owner ||
-      getApproved(tokenId) == spender ||
-      isApprovedForAll(owner, spender)
-    );
-  }
-
-  /**
-   * @dev Internal function to mint a new token
-   * Reverts if the given token ID already exists
-   * @param to The address that will own the minted token
-   * @param tokenId uint256 ID of the token to be minted by the msg.sender
-   */
-  function _mint(address to, uint256 tokenId) internal {
-    require(to != address(0));
-    _addTokenTo(to, tokenId);
-    emit Transfer(address(0), to, tokenId);
-  }
-
-  /**
-   * @dev Internal function to burn a specific token
-   * Reverts if the token does not exist
-   * @param tokenId uint256 ID of the token being burned by the msg.sender
-   */
-  function _burn(address owner, uint256 tokenId) internal {
-    _clearApproval(owner, tokenId);
-    _removeTokenFrom(owner, tokenId);
-    emit Transfer(owner, address(0), tokenId);
-  }
-
-  /**
-   * @dev Internal function to add a token ID to the list of a given address
-   * Note that this function is left internal to make ERC721Enumerable possible, but is not
-   * intended to be called by custom derived contracts: in particular, it emits no Transfer event.
-   * @param to address representing the new owner of the given token ID
-   * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
-   */
-  function _addTokenTo(address to, uint256 tokenId) internal {
-    require(_tokenOwner[tokenId] == address(0));
-    _tokenOwner[tokenId] = to;
-    _ownedTokensCount[to] = _ownedTokensCount[to].add(1);
-  }
-
-  /**
-   * @dev Internal function to remove a token ID from the list of a given address
-   * Note that this function is left internal to make ERC721Enumerable possible, but is not
-   * intended to be called by custom derived contracts: in particular, it emits no Transfer event,
-   * and doesn't clear approvals.
-   * @param from address representing the previous owner of the given token ID
-   * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
-   */
-  function _removeTokenFrom(address from, uint256 tokenId) internal {
-    require(ownerOf(tokenId) == from);
-    _ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
-    _tokenOwner[tokenId] = address(0);
-  }
-
-  /**
-   * @dev Internal function to invoke `onERC721Received` on a target address
-   * The call is not executed if the target address is not a contract
-   * @param from address representing the previous owner of the given token ID
-   * @param to target address that will receive the tokens
-   * @param tokenId uint256 ID of the token to be transferred
-   * @param _data bytes optional data to send along with the call
-   * @return whether the call correctly returned the expected magic value
-   */
-  function _checkOnERC721Received(
-    address from,
-    address to,
-    uint256 tokenId,
-    bytes _data
-  )
-    internal
-    returns (bool)
-  {
-    if (!to.isContract()) {
-      return true;
+    constructor () public {
+        // register the supported interfaces to conform to ERC721 via ERC165
+        _registerInterface(_InterfaceId_ERC721);
     }
-    bytes4 retval = IERC721Receiver(to).onERC721Received(
-      msg.sender, from, tokenId, _data);
-    return (retval == _ERC721_RECEIVED);
-  }
 
-  /**
-   * @dev Private function to clear current approval of a given token ID
-   * Reverts if the given address is not indeed the owner of the token
-   * @param owner owner of the token
-   * @param tokenId uint256 ID of the token to be transferred
-   */
-  function _clearApproval(address owner, uint256 tokenId) private {
-    require(ownerOf(tokenId) == owner);
-    if (_tokenApprovals[tokenId] != address(0)) {
-      _tokenApprovals[tokenId] = address(0);
+    /**
+     * @dev Gets the balance of the specified address
+     * @param owner address to query the balance of
+     * @return uint256 representing the amount owned by the passed address
+     */
+    function balanceOf(address owner) public view returns (uint256) {
+        require(owner != address(0));
+        return _ownedTokensCount[owner];
+    }
+
+    /**
+     * @dev Gets the owner of the specified token ID
+     * @param tokenId uint256 ID of the token to query the owner of
+     * @return owner address currently marked as the owner of the given token ID
+     */
+    function ownerOf(uint256 tokenId) public view returns (address) {
+        address owner = _tokenOwner[tokenId];
+        require(owner != address(0));
+        return owner;
+    }
+
+    /**
+     * @dev Approves another address to transfer the given token ID
+     * The zero address indicates there is no approved address.
+     * There can only be one approved address per token at a given time.
+     * Can only be called by the token owner or an approved operator.
+     * @param to address to be approved for the given token ID
+     * @param tokenId uint256 ID of the token to be approved
+     */
+    function approve(address to, uint256 tokenId) public {
+        address owner = ownerOf(tokenId);
+        require(to != owner);
+        require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
+
+        _tokenApprovals[tokenId] = to;
+        emit Approval(owner, to, tokenId);
+    }
+
+    /**
+     * @dev Gets the approved address for a token ID, or zero if no address set
+     * Reverts if the token ID does not exist.
+     * @param tokenId uint256 ID of the token to query the approval of
+     * @return address currently approved for the given token ID
+     */
+    function getApproved(uint256 tokenId) public view returns (address) {
+        require(_exists(tokenId));
+        return _tokenApprovals[tokenId];
+    }
+
+    /**
+     * @dev Sets or unsets the approval of a given operator
+     * An operator is allowed to transfer all tokens of the sender on their behalf
+     * @param to operator address to set the approval
+     * @param approved representing the status of the approval to be set
+     */
+    function setApprovalForAll(address to, bool approved) public {
+        require(to != msg.sender);
+        _operatorApprovals[msg.sender][to] = approved;
+        emit ApprovalForAll(msg.sender, to, approved);
+    }
+
+    /**
+     * @dev Tells whether an operator is approved by a given owner
+     * @param owner owner address which you want to query the approval of
+     * @param operator operator address which you want to query the approval of
+     * @return bool whether the given operator is approved by the given owner
+     */
+    function isApprovedForAll(address owner, address operator) public view returns (bool) {
+        return _operatorApprovals[owner][operator];
+    }
+
+    /**
+     * @dev Transfers the ownership of a given token ID to another address
+     * Usage of this method is discouraged, use `safeTransferFrom` whenever possible
+     * Requires the msg sender to be the owner, approved, or operator
+     * @param from current owner of the token
+     * @param to address to receive the ownership of the given token ID
+     * @param tokenId uint256 ID of the token to be transferred
+    */
+    function transferFrom(address from, address to, uint256 tokenId) public {
+        require(_isApprovedOrOwner(msg.sender, tokenId));
+        require(to != address(0));
+
+        _clearApproval(from, tokenId);
+        _removeTokenFrom(from, tokenId);
+        _addTokenTo(to, tokenId);
+
+        emit Transfer(from, to, tokenId);
+    }
+
+    /**
+     * @dev Safely transfers the ownership of a given token ID to another address
+     * If the target address is a contract, it must implement `onERC721Received`,
+     * which is called upon a safe transfer, and return the magic value
+     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
+     * the transfer is reverted.
+     *
+     * Requires the msg sender to be the owner, approved, or operator
+     * @param from current owner of the token
+     * @param to address to receive the ownership of the given token ID
+     * @param tokenId uint256 ID of the token to be transferred
+    */
+    function safeTransferFrom(address from, address to, uint256 tokenId) public {
+        // solium-disable-next-line arg-overflow
+        safeTransferFrom(from, to, tokenId, "");
+    }
+
+    /**
+     * @dev Safely transfers the ownership of a given token ID to another address
+     * If the target address is a contract, it must implement `onERC721Received`,
+     * which is called upon a safe transfer, and return the magic value
+     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
+     * the transfer is reverted.
+     * Requires the msg sender to be the owner, approved, or operator
+     * @param from current owner of the token
+     * @param to address to receive the ownership of the given token ID
+     * @param tokenId uint256 ID of the token to be transferred
+     * @param _data bytes data to send along with a safe transfer check
+     */
+    function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) public {
+        transferFrom(from, to, tokenId);
+        // solium-disable-next-line arg-overflow
+        require(_checkOnERC721Received(from, to, tokenId, _data));
+    }
+
+    /**
+     * @dev Returns whether the specified token exists
+     * @param tokenId uint256 ID of the token to query the existence of
+     * @return whether the token exists
+     */
+    function _exists(uint256 tokenId) internal view returns (bool) {
+        address owner = _tokenOwner[tokenId];
+        return owner != address(0);
+    }
+
+    /**
+     * @dev Returns whether the given spender can transfer a given token ID
+     * @param spender address of the spender to query
+     * @param tokenId uint256 ID of the token to be transferred
+     * @return bool whether the msg.sender is approved for the given token ID,
+     *    is an operator of the owner, or is the owner of the token
+     */
+    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
+        address owner = ownerOf(tokenId);
+        // Disable solium check because of
+        // https://github.com/duaraghav8/Solium/issues/175
+        // solium-disable-next-line operator-whitespace
+        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
+    }
+
+    /**
+     * @dev Internal function to mint a new token
+     * Reverts if the given token ID already exists
+     * @param to The address that will own the minted token
+     * @param tokenId uint256 ID of the token to be minted by the msg.sender
+     */
+    function _mint(address to, uint256 tokenId) internal {
+        require(to != address(0));
+        _addTokenTo(to, tokenId);
+        emit Transfer(address(0), to, tokenId);
+    }
+
+    /**
+     * @dev Internal function to burn a specific token
+     * Reverts if the token does not exist
+     * @param tokenId uint256 ID of the token being burned by the msg.sender
+     */
+    function _burn(address owner, uint256 tokenId) internal {
+        _clearApproval(owner, tokenId);
+        _removeTokenFrom(owner, tokenId);
+        emit Transfer(owner, address(0), tokenId);
+    }
+
+    /**
+     * @dev Internal function to add a token ID to the list of a given address
+     * Note that this function is left internal to make ERC721Enumerable possible, but is not
+     * intended to be called by custom derived contracts: in particular, it emits no Transfer event.
+     * @param to address representing the new owner of the given token ID
+     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
+     */
+    function _addTokenTo(address to, uint256 tokenId) internal {
+        require(_tokenOwner[tokenId] == address(0));
+        _tokenOwner[tokenId] = to;
+        _ownedTokensCount[to] = _ownedTokensCount[to].add(1);
+    }
+
+    /**
+     * @dev Internal function to remove a token ID from the list of a given address
+     * Note that this function is left internal to make ERC721Enumerable possible, but is not
+     * intended to be called by custom derived contracts: in particular, it emits no Transfer event,
+     * and doesn't clear approvals.
+     * @param from address representing the previous owner of the given token ID
+     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
+     */
+    function _removeTokenFrom(address from, uint256 tokenId) internal {
+        require(ownerOf(tokenId) == from);
+        _ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
+        _tokenOwner[tokenId] = address(0);
+    }
+
+    /**
+     * @dev Internal function to invoke `onERC721Received` on a target address
+     * The call is not executed if the target address is not a contract
+     * @param from address representing the previous owner of the given token ID
+     * @param to target address that will receive the tokens
+     * @param tokenId uint256 ID of the token to be transferred
+     * @param _data bytes optional data to send along with the call
+     * @return whether the call correctly returned the expected magic value
+     */
+    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes _data) internal returns (bool) {
+        if (!to.isContract()) {
+            return true;
+        }
+
+        bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
+        return (retval == _ERC721_RECEIVED);
+    }
+
+    /**
+     * @dev Private function to clear current approval of a given token ID
+     * Reverts if the given address is not indeed the owner of the token
+     * @param owner owner of the token
+     * @param tokenId uint256 ID of the token to be transferred
+     */
+    function _clearApproval(address owner, uint256 tokenId) private {
+        require(ownerOf(tokenId) == owner);
+        if (_tokenApprovals[tokenId] != address(0)) {
+            _tokenApprovals[tokenId] = address(0);
+        }
     }
-  }
 }
diff --git a/contracts/token/ERC721/ERC721Burnable.sol b/contracts/token/ERC721/ERC721Burnable.sol
index 71f3bcdd1..2d8732b38 100644
--- a/contracts/token/ERC721/ERC721Burnable.sol
+++ b/contracts/token/ERC721/ERC721Burnable.sol
@@ -7,15 +7,12 @@ import "./ERC721.sol";
  * @dev ERC721 Token that can be irreversibly burned (destroyed).
  */
 contract ERC721Burnable is ERC721 {
-
-  /**
-   * @dev Burns a specific ERC721 token.
-   * @param tokenId uint256 id of the ERC721 token to be burned.
-   */
-  function burn(uint256 tokenId)
-    public
-  {
-    require(_isApprovedOrOwner(msg.sender, tokenId));
-    _burn(ownerOf(tokenId), tokenId);
-  }
+    /**
+     * @dev Burns a specific ERC721 token.
+     * @param tokenId uint256 id of the ERC721 token to be burned.
+     */
+    function burn(uint256 tokenId) public {
+        require(_isApprovedOrOwner(msg.sender, tokenId));
+        _burn(ownerOf(tokenId), tokenId);
+    }
 }
diff --git a/contracts/token/ERC721/ERC721Enumerable.sol b/contracts/token/ERC721/ERC721Enumerable.sol
index 234307755..ff8c1b9ee 100644
--- a/contracts/token/ERC721/ERC721Enumerable.sol
+++ b/contracts/token/ERC721/ERC721Enumerable.sol
@@ -9,146 +9,139 @@ import "../../introspection/ERC165.sol";
  * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
  */
 contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
-  // Mapping from owner to list of owned token IDs
-  mapping(address => uint256[]) private _ownedTokens;
+    // Mapping from owner to list of owned token IDs
+    mapping(address => uint256[]) private _ownedTokens;
 
-  // Mapping from token ID to index of the owner tokens list
-  mapping(uint256 => uint256) private _ownedTokensIndex;
+    // Mapping from token ID to index of the owner tokens list
+    mapping(uint256 => uint256) private _ownedTokensIndex;
 
-  // Array with all token ids, used for enumeration
-  uint256[] private _allTokens;
+    // Array with all token ids, used for enumeration
+    uint256[] private _allTokens;
 
-  // Mapping from token id to position in the allTokens array
-  mapping(uint256 => uint256) private _allTokensIndex;
+    // Mapping from token id to position in the allTokens array
+    mapping(uint256 => uint256) private _allTokensIndex;
 
-  bytes4 private constant _InterfaceId_ERC721Enumerable = 0x780e9d63;
-  /**
-   * 0x780e9d63 ===
-   *   bytes4(keccak256('totalSupply()')) ^
-   *   bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
-   *   bytes4(keccak256('tokenByIndex(uint256)'))
-   */
+    bytes4 private constant _InterfaceId_ERC721Enumerable = 0x780e9d63;
+    /**
+     * 0x780e9d63 ===
+     *     bytes4(keccak256('totalSupply()')) ^
+     *     bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
+     *     bytes4(keccak256('tokenByIndex(uint256)'))
+     */
 
-  /**
-   * @dev Constructor function
-   */
-  constructor() public {
-    // register the supported interface to conform to ERC721 via ERC165
-    _registerInterface(_InterfaceId_ERC721Enumerable);
-  }
+    /**
+     * @dev Constructor function
+     */
+    constructor () public {
+        // register the supported interface to conform to ERC721 via ERC165
+        _registerInterface(_InterfaceId_ERC721Enumerable);
+    }
 
-  /**
-   * @dev Gets the token ID at a given index of the tokens list of the requested owner
-   * @param owner address owning the tokens list to be accessed
-   * @param index uint256 representing the index to be accessed of the requested tokens list
-   * @return uint256 token ID at the given index of the tokens list owned by the requested address
-   */
-  function tokenOfOwnerByIndex(
-    address owner,
-    uint256 index
-  )
-    public
-    view
-    returns (uint256)
-  {
-    require(index < balanceOf(owner));
-    return _ownedTokens[owner][index];
-  }
+    /**
+     * @dev Gets the token ID at a given index of the tokens list of the requested owner
+     * @param owner address owning the tokens list to be accessed
+     * @param index uint256 representing the index to be accessed of the requested tokens list
+     * @return uint256 token ID at the given index of the tokens list owned by the requested address
+     */
+    function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
+        require(index < balanceOf(owner));
+        return _ownedTokens[owner][index];
+    }
 
-  /**
-   * @dev Gets the total amount of tokens stored by the contract
-   * @return uint256 representing the total amount of tokens
-   */
-  function totalSupply() public view returns (uint256) {
-    return _allTokens.length;
-  }
+    /**
+     * @dev Gets the total amount of tokens stored by the contract
+     * @return uint256 representing the total amount of tokens
+     */
+    function totalSupply() public view returns (uint256) {
+        return _allTokens.length;
+    }
 
-  /**
-   * @dev Gets the token ID at a given index of all the tokens in this contract
-   * Reverts if the index is greater or equal to the total number of tokens
-   * @param index uint256 representing the index to be accessed of the tokens list
-   * @return uint256 token ID at the given index of the tokens list
-   */
-  function tokenByIndex(uint256 index) public view returns (uint256) {
-    require(index < totalSupply());
-    return _allTokens[index];
-  }
+    /**
+     * @dev Gets the token ID at a given index of all the tokens in this contract
+     * Reverts if the index is greater or equal to the total number of tokens
+     * @param index uint256 representing the index to be accessed of the tokens list
+     * @return uint256 token ID at the given index of the tokens list
+     */
+    function tokenByIndex(uint256 index) public view returns (uint256) {
+        require(index < totalSupply());
+        return _allTokens[index];
+    }
 
-  /**
-   * @dev Internal function to add a token ID to the list of a given address
-   * This function is internal due to language limitations, see the note in ERC721.sol.
-   * It is not intended to be called by custom derived contracts: in particular, it emits no Transfer event.
-   * @param to address representing the new owner of the given token ID
-   * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
-   */
-  function _addTokenTo(address to, uint256 tokenId) internal {
-    super._addTokenTo(to, tokenId);
-    uint256 length = _ownedTokens[to].length;
-    _ownedTokens[to].push(tokenId);
-    _ownedTokensIndex[tokenId] = length;
-  }
+    /**
+     * @dev Internal function to add a token ID to the list of a given address
+     * This function is internal due to language limitations, see the note in ERC721.sol.
+     * It is not intended to be called by custom derived contracts: in particular, it emits no Transfer event.
+     * @param to address representing the new owner of the given token ID
+     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
+     */
+    function _addTokenTo(address to, uint256 tokenId) internal {
+        super._addTokenTo(to, tokenId);
+        uint256 length = _ownedTokens[to].length;
+        _ownedTokens[to].push(tokenId);
+        _ownedTokensIndex[tokenId] = length;
+    }
 
-  /**
-   * @dev Internal function to remove a token ID from the list of a given address
-   * This function is internal due to language limitations, see the note in ERC721.sol.
-   * It is not intended to be called by custom derived contracts: in particular, it emits no Transfer event,
-   * and doesn't clear approvals.
-   * @param from address representing the previous owner of the given token ID
-   * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
-   */
-  function _removeTokenFrom(address from, uint256 tokenId) internal {
-    super._removeTokenFrom(from, tokenId);
+    /**
+     * @dev Internal function to remove a token ID from the list of a given address
+     * This function is internal due to language limitations, see the note in ERC721.sol.
+     * It is not intended to be called by custom derived contracts: in particular, it emits no Transfer event,
+     * and doesn't clear approvals.
+     * @param from address representing the previous owner of the given token ID
+     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
+     */
+    function _removeTokenFrom(address from, uint256 tokenId) internal {
+        super._removeTokenFrom(from, tokenId);
 
-    // To prevent a gap in the array, we store the last token in the index of the token to delete, and
-    // then delete the last slot.
-    uint256 tokenIndex = _ownedTokensIndex[tokenId];
-    uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
-    uint256 lastToken = _ownedTokens[from][lastTokenIndex];
+        // To prevent a gap in the array, we store the last token in the index of the token to delete, and
+        // then delete the last slot.
+        uint256 tokenIndex = _ownedTokensIndex[tokenId];
+        uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
+        uint256 lastToken = _ownedTokens[from][lastTokenIndex];
 
-    _ownedTokens[from][tokenIndex] = lastToken;
-    // This also deletes the contents at the last position of the array
-    _ownedTokens[from].length--;
+        _ownedTokens[from][tokenIndex] = lastToken;
+        // This also deletes the contents at the last position of the array
+        _ownedTokens[from].length--;
 
-    // Note that this will handle single-element arrays. In that case, both tokenIndex and lastTokenIndex are going to
-    // be zero. Then we can make sure that we will remove tokenId from the ownedTokens list since we are first swapping
-    // the lastToken to the first position, and then dropping the element placed in the last position of the list
+        // Note that this will handle single-element arrays. In that case, both tokenIndex and lastTokenIndex are going to
+        // be zero. Then we can make sure that we will remove tokenId from the ownedTokens list since we are first swapping
+        // the lastToken to the first position, and then dropping the element placed in the last position of the list
 
-    _ownedTokensIndex[tokenId] = 0;
-    _ownedTokensIndex[lastToken] = tokenIndex;
-  }
+        _ownedTokensIndex[tokenId] = 0;
+        _ownedTokensIndex[lastToken] = tokenIndex;
+    }
 
-  /**
-   * @dev Internal function to mint a new token
-   * Reverts if the given token ID already exists
-   * @param to address the beneficiary that will own the minted token
-   * @param tokenId uint256 ID of the token to be minted by the msg.sender
-   */
-  function _mint(address to, uint256 tokenId) internal {
-    super._mint(to, tokenId);
+    /**
+     * @dev Internal function to mint a new token
+     * Reverts if the given token ID already exists
+     * @param to address the beneficiary that will own the minted token
+     * @param tokenId uint256 ID of the token to be minted by the msg.sender
+     */
+    function _mint(address to, uint256 tokenId) internal {
+        super._mint(to, tokenId);
 
-    _allTokensIndex[tokenId] = _allTokens.length;
-    _allTokens.push(tokenId);
-  }
+        _allTokensIndex[tokenId] = _allTokens.length;
+        _allTokens.push(tokenId);
+    }
 
-  /**
-   * @dev Internal function to burn a specific token
-   * Reverts if the token does not exist
-   * @param owner owner of the token to burn
-   * @param tokenId uint256 ID of the token being burned by the msg.sender
-   */
-  function _burn(address owner, uint256 tokenId) internal {
-    super._burn(owner, tokenId);
+    /**
+     * @dev Internal function to burn a specific token
+     * Reverts if the token does not exist
+     * @param owner owner of the token to burn
+     * @param tokenId uint256 ID of the token being burned by the msg.sender
+     */
+    function _burn(address owner, uint256 tokenId) internal {
+        super._burn(owner, tokenId);
 
-    // Reorg all tokens array
-    uint256 tokenIndex = _allTokensIndex[tokenId];
-    uint256 lastTokenIndex = _allTokens.length.sub(1);
-    uint256 lastToken = _allTokens[lastTokenIndex];
+        // Reorg all tokens array
+        uint256 tokenIndex = _allTokensIndex[tokenId];
+        uint256 lastTokenIndex = _allTokens.length.sub(1);
+        uint256 lastToken = _allTokens[lastTokenIndex];
 
-    _allTokens[tokenIndex] = lastToken;
-    _allTokens[lastTokenIndex] = 0;
+        _allTokens[tokenIndex] = lastToken;
+        _allTokens[lastTokenIndex] = 0;
 
-    _allTokens.length--;
-    _allTokensIndex[tokenId] = 0;
-    _allTokensIndex[lastToken] = tokenIndex;
-  }
+        _allTokens.length--;
+        _allTokensIndex[tokenId] = 0;
+        _allTokensIndex[lastToken] = tokenIndex;
+    }
 }
diff --git a/contracts/token/ERC721/ERC721Full.sol b/contracts/token/ERC721/ERC721Full.sol
index 293637501..1c964ea8e 100644
--- a/contracts/token/ERC721/ERC721Full.sol
+++ b/contracts/token/ERC721/ERC721Full.sol
@@ -11,8 +11,5 @@ import "./ERC721Metadata.sol";
  * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
  */
 contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
-  constructor(string name, string symbol) ERC721Metadata(name, symbol)
-    public
-  {
-  }
+    constructor (string name, string symbol) ERC721Metadata(name, symbol) public {}
 }
diff --git a/contracts/token/ERC721/ERC721Holder.sol b/contracts/token/ERC721/ERC721Holder.sol
index cf0e9ce55..87480b9fa 100644
--- a/contracts/token/ERC721/ERC721Holder.sol
+++ b/contracts/token/ERC721/ERC721Holder.sol
@@ -3,15 +3,7 @@ pragma solidity ^0.4.24;
 import "./IERC721Receiver.sol";
 
 contract ERC721Holder is IERC721Receiver {
-  function onERC721Received(
-    address,
-    address,
-    uint256,
-    bytes
-  )
-    public
-    returns(bytes4)
-  {
-    return this.onERC721Received.selector;
-  }
+    function onERC721Received(address, address, uint256, bytes) public returns (bytes4) {
+        return this.onERC721Received.selector;
+    }
 }
diff --git a/contracts/token/ERC721/ERC721Metadata.sol b/contracts/token/ERC721/ERC721Metadata.sol
index bd1105188..522b626e8 100644
--- a/contracts/token/ERC721/ERC721Metadata.sol
+++ b/contracts/token/ERC721/ERC721Metadata.sol
@@ -5,83 +5,83 @@ import "./IERC721Metadata.sol";
 import "../../introspection/ERC165.sol";
 
 contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
-  // Token name
-  string private _name;
+    // Token name
+    string private _name;
 
-  // Token symbol
-  string private _symbol;
+    // Token symbol
+    string private _symbol;
 
-  // Optional mapping for token URIs
-  mapping(uint256 => string) private _tokenURIs;
+    // Optional mapping for token URIs
+    mapping(uint256 => string) private _tokenURIs;
 
-  bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
-  /**
-   * 0x5b5e139f ===
-   *   bytes4(keccak256('name()')) ^
-   *   bytes4(keccak256('symbol()')) ^
-   *   bytes4(keccak256('tokenURI(uint256)'))
-   */
+    bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
+    /**
+     * 0x5b5e139f ===
+     *     bytes4(keccak256('name()')) ^
+     *     bytes4(keccak256('symbol()')) ^
+     *     bytes4(keccak256('tokenURI(uint256)'))
+     */
 
-  /**
-   * @dev Constructor function
-   */
-  constructor(string name, string symbol) public {
-    _name = name;
-    _symbol = symbol;
+    /**
+     * @dev Constructor function
+     */
+    constructor (string name, string symbol) public {
+        _name = name;
+        _symbol = symbol;
 
-    // register the supported interfaces to conform to ERC721 via ERC165
-    _registerInterface(InterfaceId_ERC721Metadata);
-  }
-
-  /**
-   * @dev Gets the token name
-   * @return string representing the token name
-   */
-  function name() external view returns (string) {
-    return _name;
-  }
-
-  /**
-   * @dev Gets the token symbol
-   * @return string representing the token symbol
-   */
-  function symbol() external view returns (string) {
-    return _symbol;
-  }
-
-  /**
-   * @dev Returns an URI for a given token ID
-   * Throws if the token ID does not exist. May return an empty string.
-   * @param tokenId uint256 ID of the token to query
-   */
-  function tokenURI(uint256 tokenId) external view returns (string) {
-    require(_exists(tokenId));
-    return _tokenURIs[tokenId];
-  }
-
-  /**
-   * @dev Internal function to set the token URI for a given token
-   * Reverts if the token ID does not exist
-   * @param tokenId uint256 ID of the token to set its URI
-   * @param uri string URI to assign
-   */
-  function _setTokenURI(uint256 tokenId, string uri) internal {
-    require(_exists(tokenId));
-    _tokenURIs[tokenId] = uri;
-  }
-
-  /**
-   * @dev Internal function to burn a specific token
-   * Reverts if the token does not exist
-   * @param owner owner of the token to burn
-   * @param tokenId uint256 ID of the token being burned by the msg.sender
-   */
-  function _burn(address owner, uint256 tokenId) internal {
-    super._burn(owner, tokenId);
-
-    // Clear metadata (if any)
-    if (bytes(_tokenURIs[tokenId]).length != 0) {
-      delete _tokenURIs[tokenId];
+        // register the supported interfaces to conform to ERC721 via ERC165
+        _registerInterface(InterfaceId_ERC721Metadata);
+    }
+
+    /**
+     * @dev Gets the token name
+     * @return string representing the token name
+     */
+    function name() external view returns (string) {
+        return _name;
+    }
+
+    /**
+     * @dev Gets the token symbol
+     * @return string representing the token symbol
+     */
+    function symbol() external view returns (string) {
+        return _symbol;
+    }
+
+    /**
+     * @dev Returns an URI for a given token ID
+     * Throws if the token ID does not exist. May return an empty string.
+     * @param tokenId uint256 ID of the token to query
+     */
+    function tokenURI(uint256 tokenId) external view returns (string) {
+        require(_exists(tokenId));
+        return _tokenURIs[tokenId];
+    }
+
+    /**
+     * @dev Internal function to set the token URI for a given token
+     * Reverts if the token ID does not exist
+     * @param tokenId uint256 ID of the token to set its URI
+     * @param uri string URI to assign
+     */
+    function _setTokenURI(uint256 tokenId, string uri) internal {
+        require(_exists(tokenId));
+        _tokenURIs[tokenId] = uri;
+    }
+
+    /**
+     * @dev Internal function to burn a specific token
+     * Reverts if the token does not exist
+     * @param owner owner of the token to burn
+     * @param tokenId uint256 ID of the token being burned by the msg.sender
+     */
+    function _burn(address owner, uint256 tokenId) internal {
+        super._burn(owner, tokenId);
+
+        // Clear metadata (if any)
+        if (bytes(_tokenURIs[tokenId]).length != 0) {
+            delete _tokenURIs[tokenId];
+        }
     }
-  }
 }
diff --git a/contracts/token/ERC721/ERC721MetadataMintable.sol b/contracts/token/ERC721/ERC721MetadataMintable.sol
index 95a9f2124..6e20f83a3 100644
--- a/contracts/token/ERC721/ERC721MetadataMintable.sol
+++ b/contracts/token/ERC721/ERC721MetadataMintable.sol
@@ -9,24 +9,16 @@ import "../../access/roles/MinterRole.sol";
  * @dev ERC721 minting logic with metadata
  */
 contract ERC721MetadataMintable is ERC721, ERC721Metadata, MinterRole {
-  /**
-   * @dev Function to mint tokens
-   * @param to The address that will receive the minted tokens.
-   * @param tokenId The token id to mint.
-   * @param tokenURI The token URI of the minted token.
-   * @return A boolean that indicates if the operation was successful.
-   */
-  function mintWithTokenURI(
-    address to,
-    uint256 tokenId,
-    string tokenURI
-  )
-    public
-    onlyMinter
-    returns (bool)
-  {
-    _mint(to, tokenId);
-    _setTokenURI(tokenId, tokenURI);
-    return true;
-  }
+    /**
+     * @dev Function to mint tokens
+     * @param to The address that will receive the minted tokens.
+     * @param tokenId The token id to mint.
+     * @param tokenURI The token URI of the minted token.
+     * @return A boolean that indicates if the operation was successful.
+     */
+    function mintWithTokenURI(address to, uint256 tokenId, string tokenURI) public onlyMinter returns (bool) {
+        _mint(to, tokenId);
+        _setTokenURI(tokenId, tokenURI);
+        return true;
+    }
 }
diff --git a/contracts/token/ERC721/ERC721Mintable.sol b/contracts/token/ERC721/ERC721Mintable.sol
index 74b7b0186..48a7f2095 100644
--- a/contracts/token/ERC721/ERC721Mintable.sol
+++ b/contracts/token/ERC721/ERC721Mintable.sol
@@ -8,21 +8,14 @@ import "../../access/roles/MinterRole.sol";
  * @dev ERC721 minting logic
  */
 contract ERC721Mintable is ERC721, MinterRole {
-  /**
-   * @dev Function to mint tokens
-   * @param to The address that will receive the minted tokens.
-   * @param tokenId The token id to mint.
-   * @return A boolean that indicates if the operation was successful.
-   */
-  function mint(
-    address to,
-    uint256 tokenId
-  )
-    public
-    onlyMinter
-    returns (bool)
-  {
-    _mint(to, tokenId);
-    return true;
-  }
+    /**
+     * @dev Function to mint tokens
+     * @param to The address that will receive the minted tokens.
+     * @param tokenId The token id to mint.
+     * @return A boolean that indicates if the operation was successful.
+     */
+    function mint(address to, uint256 tokenId) public onlyMinter returns (bool) {
+        _mint(to, tokenId);
+        return true;
+    }
 }
diff --git a/contracts/token/ERC721/ERC721Pausable.sol b/contracts/token/ERC721/ERC721Pausable.sol
index c66d9da1f..0fb2ef3b5 100644
--- a/contracts/token/ERC721/ERC721Pausable.sol
+++ b/contracts/token/ERC721/ERC721Pausable.sol
@@ -8,34 +8,15 @@ import "../../lifecycle/Pausable.sol";
  * @dev ERC721 modified with pausable transfers.
  **/
 contract ERC721Pausable is ERC721, Pausable {
-  function approve(
-    address to,
-    uint256 tokenId
-  )
-    public
-    whenNotPaused
-  {
-    super.approve(to, tokenId);
-  }
+    function approve(address to, uint256 tokenId) public whenNotPaused {
+        super.approve(to, tokenId);
+    }
 
-  function setApprovalForAll(
-    address to,
-    bool approved
-  )
-    public
-    whenNotPaused
-  {
-    super.setApprovalForAll(to, approved);
-  }
+    function setApprovalForAll(address to, bool approved) public whenNotPaused {
+        super.setApprovalForAll(to, approved);
+    }
 
-  function transferFrom(
-    address from,
-    address to,
-    uint256 tokenId
-  )
-    public
-    whenNotPaused
-  {
-    super.transferFrom(from, to, tokenId);
-  }
+    function transferFrom(address from, address to, uint256 tokenId) public whenNotPaused {
+        super.transferFrom(from, to, tokenId);
+    }
 }
diff --git a/contracts/token/ERC721/IERC721.sol b/contracts/token/ERC721/IERC721.sol
index 24bc6a242..003802182 100644
--- a/contracts/token/ERC721/IERC721.sol
+++ b/contracts/token/ERC721/IERC721.sol
@@ -7,43 +7,21 @@ import "../../introspection/IERC165.sol";
  * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
  */
 contract IERC721 is IERC165 {
+    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
+    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
+    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
 
-  event Transfer(
-    address indexed from,
-    address indexed to,
-    uint256 indexed tokenId
-  );
-  event Approval(
-    address indexed owner,
-    address indexed approved,
-    uint256 indexed tokenId
-  );
-  event ApprovalForAll(
-    address indexed owner,
-    address indexed operator,
-    bool approved
-  );
+    function balanceOf(address owner) public view returns (uint256 balance);
+    function ownerOf(uint256 tokenId) public view returns (address owner);
 
-  function balanceOf(address owner) public view returns (uint256 balance);
-  function ownerOf(uint256 tokenId) public view returns (address owner);
+    function approve(address to, uint256 tokenId) public;
+    function getApproved(uint256 tokenId) public view returns (address operator);
 
-  function approve(address to, uint256 tokenId) public;
-  function getApproved(uint256 tokenId)
-    public view returns (address operator);
+    function setApprovalForAll(address operator, bool _approved) public;
+    function isApprovedForAll(address owner, address operator) public view returns (bool);
 
-  function setApprovalForAll(address operator, bool _approved) public;
-  function isApprovedForAll(address owner, address operator)
-    public view returns (bool);
+    function transferFrom(address from, address to, uint256 tokenId) public;
+    function safeTransferFrom(address from, address to, uint256 tokenId) public;
 
-  function transferFrom(address from, address to, uint256 tokenId) public;
-  function safeTransferFrom(address from, address to, uint256 tokenId)
-    public;
-
-  function safeTransferFrom(
-    address from,
-    address to,
-    uint256 tokenId,
-    bytes data
-  )
-    public;
+    function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) public;
 }
diff --git a/contracts/token/ERC721/IERC721Enumerable.sol b/contracts/token/ERC721/IERC721Enumerable.sol
index b772f2507..06a50ed1b 100644
--- a/contracts/token/ERC721/IERC721Enumerable.sol
+++ b/contracts/token/ERC721/IERC721Enumerable.sol
@@ -7,14 +7,8 @@ import "./IERC721.sol";
  * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
  */
 contract IERC721Enumerable is IERC721 {
-  function totalSupply() public view returns (uint256);
-  function tokenOfOwnerByIndex(
-    address owner,
-    uint256 index
-  )
-    public
-    view
-    returns (uint256 tokenId);
+    function totalSupply() public view returns (uint256);
+    function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
 
-  function tokenByIndex(uint256 index) public view returns (uint256);
+    function tokenByIndex(uint256 index) public view returns (uint256);
 }
diff --git a/contracts/token/ERC721/IERC721Metadata.sol b/contracts/token/ERC721/IERC721Metadata.sol
index 15b5ae4c6..2d7d1b249 100644
--- a/contracts/token/ERC721/IERC721Metadata.sol
+++ b/contracts/token/ERC721/IERC721Metadata.sol
@@ -7,7 +7,7 @@ import "./IERC721.sol";
  * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
  */
 contract IERC721Metadata is IERC721 {
-  function name() external view returns (string);
-  function symbol() external view returns (string);
-  function tokenURI(uint256 tokenId) external view returns (string);
+    function name() external view returns (string);
+    function symbol() external view returns (string);
+    function tokenURI(uint256 tokenId) external view returns (string);
 }
diff --git a/contracts/token/ERC721/IERC721Receiver.sol b/contracts/token/ERC721/IERC721Receiver.sol
index e692f7e2c..7c360d7b4 100644
--- a/contracts/token/ERC721/IERC721Receiver.sol
+++ b/contracts/token/ERC721/IERC721Receiver.sol
@@ -6,26 +6,19 @@ pragma solidity ^0.4.24;
  * from ERC721 asset contracts.
  */
 contract IERC721Receiver {
-  /**
-   * @notice Handle the receipt of an NFT
-   * @dev The ERC721 smart contract calls this function on the recipient
-   * after a `safeTransfer`. This function MUST return the function selector,
-   * otherwise the caller will revert the transaction. The selector to be
-   * returned can be obtained as `this.onERC721Received.selector`. This
-   * function MAY throw to revert and reject the transfer.
-   * Note: the ERC721 contract address is always the message sender.
-   * @param operator The address which called `safeTransferFrom` function
-   * @param from The address which previously owned the token
-   * @param tokenId The NFT identifier which is being transferred
-   * @param data Additional data with no specified format
-   * @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
-   */
-  function onERC721Received(
-    address operator,
-    address from,
-    uint256 tokenId,
-    bytes data
-  )
-    public
-    returns(bytes4);
+    /**
+     * @notice Handle the receipt of an NFT
+     * @dev The ERC721 smart contract calls this function on the recipient
+     * after a `safeTransfer`. This function MUST return the function selector,
+     * otherwise the caller will revert the transaction. The selector to be
+     * returned can be obtained as `this.onERC721Received.selector`. This
+     * function MAY throw to revert and reject the transfer.
+     * Note: the ERC721 contract address is always the message sender.
+     * @param operator The address which called `safeTransferFrom` function
+     * @param from The address which previously owned the token
+     * @param tokenId The NFT identifier which is being transferred
+     * @param data Additional data with no specified format
+     * @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
+     */
+    function onERC721Received(address operator, address from, uint256 tokenId, bytes data) public returns (bytes4);
 }
diff --git a/contracts/utils/Address.sol b/contracts/utils/Address.sol
index 92a43ff9c..c44dfa17f 100644
--- a/contracts/utils/Address.sol
+++ b/contracts/utils/Address.sol
@@ -4,25 +4,23 @@ pragma solidity ^0.4.24;
  * Utility library of inline functions on addresses
  */
 library Address {
-
-  /**
-   * Returns whether the target address is a contract
-   * @dev This function will return false if invoked during the constructor of a contract,
-   * as the code is not actually created until after the constructor finishes.
-   * @param account address of the account to check
-   * @return whether the target address is a contract
-   */
-  function isContract(address account) internal view returns (bool) {
-    uint256 size;
-    // XXX Currently there is no better way to check if there is a contract in an address
-    // than to check the size of the code at that address.
-    // See https://ethereum.stackexchange.com/a/14016/36603
-    // for more details about how this works.
-    // TODO Check this again before the Serenity release, because all addresses will be
-    // contracts then.
-    // solium-disable-next-line security/no-inline-assembly
-    assembly { size := extcodesize(account) }
-    return size > 0;
-  }
-
+    /**
+     * Returns whether the target address is a contract
+     * @dev This function will return false if invoked during the constructor of a contract,
+     * as the code is not actually created until after the constructor finishes.
+     * @param account address of the account to check
+     * @return whether the target address is a contract
+     */
+    function isContract(address account) internal view returns (bool) {
+        uint256 size;
+        // XXX Currently there is no better way to check if there is a contract in an address
+        // than to check the size of the code at that address.
+        // See https://ethereum.stackexchange.com/a/14016/36603
+        // for more details about how this works.
+        // TODO Check this again before the Serenity release, because all addresses will be
+        // contracts then.
+        // solium-disable-next-line security/no-inline-assembly
+        assembly { size := extcodesize(account) }
+        return size > 0;
+    }
 }
diff --git a/contracts/utils/Arrays.sol b/contracts/utils/Arrays.sol
index 6882ea995..7d8e29339 100644
--- a/contracts/utils/Arrays.sol
+++ b/contracts/utils/Arrays.sol
@@ -8,49 +8,41 @@ import "../math/Math.sol";
  * @dev Utility library of inline array functions
  */
 library Arrays {
+    /**
+     * @dev Upper bound search function which is kind of binary search algoritm. It searches sorted
+     * array to find index of the element value. If element is found then returns it's index otherwise
+     * it returns index of first element which is grater than searched value. If searched element is
+     * bigger than any array element function then returns first index after last element (i.e. all
+     * values inside the array are smaller than the target). Complexity O(log n).
+     * @param array The array sorted in ascending order.
+     * @param element The element's value to be find.
+     * @return The calculated index value. Returns 0 for empty array.
+     */
+    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
+        if (array.length == 0) {
+            return 0;
+        }
 
-  /**
-   * @dev Upper bound search function which is kind of binary search algoritm. It searches sorted
-   * array to find index of the element value. If element is found then returns it's index otherwise
-   * it returns index of first element which is grater than searched value. If searched element is
-   * bigger than any array element function then returns first index after last element (i.e. all
-   * values inside the array are smaller than the target). Complexity O(log n).
-   * @param array The array sorted in ascending order.
-   * @param element The element's value to be find.
-   * @return The calculated index value. Returns 0 for empty array.
-   */
-  function findUpperBound(
-    uint256[] storage array,
-    uint256 element
-  ) 
-    internal
-    view
-    returns (uint256)
-  {
-    if (array.length == 0) {
-      return 0;
+        uint256 low = 0;
+        uint256 high = array.length;
+
+        while (low < high) {
+            uint256 mid = Math.average(low, high);
+
+            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
+            // because Math.average rounds down (it does integer division with truncation).
+            if (array[mid] > element) {
+                high = mid;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
+        if (low > 0 && array[low - 1] == element) {
+            return low - 1;
+        } else {
+            return low;
+        }
     }
-    
-    uint256 low = 0;
-    uint256 high = array.length;
-
-    while (low < high) {
-      uint256 mid = Math.average(low, high);
-
-      // Note that mid will always be strictly less than high (i.e. it will be a valid array index) 
-      // because Math.average rounds down (it does integer division with truncation).
-      if (array[mid] > element) {
-        high = mid;
-      } else {
-        low = mid + 1;
-      }
-    }
-
-    // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
-    if (low > 0 && array[low - 1] == element) {
-      return low - 1;
-    } else {
-      return low;
-    }
-  }
 }
diff --git a/contracts/utils/ReentrancyGuard.sol b/contracts/utils/ReentrancyGuard.sol
index 7a2895da2..40af0f688 100644
--- a/contracts/utils/ReentrancyGuard.sol
+++ b/contracts/utils/ReentrancyGuard.sol
@@ -7,28 +7,26 @@ pragma solidity ^0.4.24;
  * mark it `external`.
  */
 contract ReentrancyGuard {
+    /// @dev counter to allow mutex lock with only one SSTORE operation
+    uint256 private _guardCounter;
 
-  /// @dev counter to allow mutex lock with only one SSTORE operation
-  uint256 private _guardCounter;
-
-  constructor() internal {
-    // The counter starts at one to prevent changing it from zero to a non-zero
-    // value, which is a more expensive operation.
-    _guardCounter = 1;
-  }
-
-  /**
-   * @dev Prevents a contract from calling itself, directly or indirectly.
-   * Calling a `nonReentrant` function from another `nonReentrant`
-   * function is not supported. It is possible to prevent this from happening
-   * by making the `nonReentrant` function external, and make it call a
-   * `private` function that does the actual work.
-   */
-  modifier nonReentrant() {
-    _guardCounter += 1;
-    uint256 localCounter = _guardCounter;
-    _;
-    require(localCounter == _guardCounter);
-  }
+    constructor () internal {
+        // The counter starts at one to prevent changing it from zero to a non-zero
+        // value, which is a more expensive operation.
+        _guardCounter = 1;
+    }
 
+    /**
+     * @dev Prevents a contract from calling itself, directly or indirectly.
+     * Calling a `nonReentrant` function from another `nonReentrant`
+     * function is not supported. It is possible to prevent this from happening
+     * by making the `nonReentrant` function external, and make it call a
+     * `private` function that does the actual work.
+     */
+    modifier nonReentrant() {
+        _guardCounter += 1;
+        uint256 localCounter = _guardCounter;
+        _;
+        require(localCounter == _guardCounter);
+    }
 }