chore: Configure prettier-solidity and run prettier-solidity [TKR-532] (#592)

* add prettier-solidity + config

* run prettier

* update lockfile

* run prettier again

* Prettier missed one /:

* keep bridge adapter the same

* yarn prettier

.prettierignore

@@ -85,4 +85,3 @@ lib
 package.json
 packages/*/docs
 docs/
-*.sol

.prettierrc

@@ -4,5 +4,17 @@
     "singleQuote": true,
     "trailingComma": "all",
     "bracketSpacing": true,
-    "arrowParens": "avoid"
+    "arrowParens": "avoid",
+    "overrides": [
+        {
+          "files": "**/*.sol",
+          "options": {
+            "printWidth": 120,
+            "tabWidth": 4,
+            "useTabs": false,
+            "singleQuote": false,
+            "bracketSpacing": false
+          }
+        }
+      ]
 }

contracts/erc20/contracts/src/ERC20Token.sol

@@ -20,12 +20,9 @@ pragma solidity ^0.5.9;
 
 import "./interfaces/IERC20Token.sol";
 
-
+contract ERC20Token is IERC20Token {
-contract ERC20Token is
+    mapping(address => uint256) internal balances;
-    IERC20Token
+    mapping(address => mapping(address => uint256)) internal allowed;
-{
-    mapping (address => uint256) internal balances;
-    mapping (address => mapping (address => uint256)) internal allowed;
 
     uint256 internal _totalSupply;
 
@@ -33,27 +30,14 @@ contract ERC20Token is
     /// @param _to The address of the recipient
     /// @param _value The amount of token to be transferred
     /// @return True if transfer was successful
-    function transfer(address _to, uint256 _value)
+    function transfer(address _to, uint256 _value) external returns (bool) {
-        external
+        require(balances[msg.sender] >= _value, "ERC20_INSUFFICIENT_BALANCE");
-        returns (bool)
+        require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");
-    {
-        require(
-            balances[msg.sender] >= _value,
-            "ERC20_INSUFFICIENT_BALANCE"
-        );
-        require(
-            balances[_to] + _value >= balances[_to],
-            "UINT256_OVERFLOW"
-        );
 
         balances[msg.sender] -= _value;
         balances[_to] += _value;
 
-        emit Transfer(
+        emit Transfer(msg.sender, _to, _value);
-            msg.sender,
-            _to,
-            _value
-        );
 
         return true;
     }
@@ -67,32 +51,16 @@ contract ERC20Token is
         address _from,
         address _to,
         uint256 _value
-    )
+    ) external returns (bool) {
-        external
+        require(balances[_from] >= _value, "ERC20_INSUFFICIENT_BALANCE");
-        returns (bool)
+        require(allowed[_from][msg.sender] >= _value, "ERC20_INSUFFICIENT_ALLOWANCE");
-    {
+        require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");
-        require(
-            balances[_from] >= _value,
-            "ERC20_INSUFFICIENT_BALANCE"
-        );
-        require(
-            allowed[_from][msg.sender] >= _value,
-            "ERC20_INSUFFICIENT_ALLOWANCE"
-        );
-        require(
-            balances[_to] + _value >= balances[_to],
-            "UINT256_OVERFLOW"
-        );
 
         balances[_to] += _value;
         balances[_from] -= _value;
         allowed[_from][msg.sender] -= _value;
 
-        emit Transfer(
+        emit Transfer(_from, _to, _value);
-            _from,
-            _to,
-            _value
-        );
 
         return true;
     }
@@ -101,48 +69,29 @@ contract ERC20Token is
     /// @param _spender The address of the account able to transfer the tokens
     /// @param _value The amount of wei to be approved for transfer
     /// @return Always true if the call has enough gas to complete execution
-    function approve(address _spender, uint256 _value)
+    function approve(address _spender, uint256 _value) external returns (bool) {
-        external
-        returns (bool)
-    {
         allowed[msg.sender][_spender] = _value;
-        emit Approval(
+        emit Approval(msg.sender, _spender, _value);
-            msg.sender,
-            _spender,
-            _value
-        );
         return true;
     }
 
     /// @dev Query total supply of token
     /// @return Total supply of token
-    function totalSupply()
+    function totalSupply() external view returns (uint256) {
-        external
-        view
-        returns (uint256)
-    {
         return _totalSupply;
     }
 
     /// @dev Query the balance of owner
     /// @param _owner The address from which the balance will be retrieved
     /// @return Balance of owner
-    function balanceOf(address _owner)
+    function balanceOf(address _owner) external view returns (uint256) {
-        external
-        view
-        returns (uint256)
-    {
         return balances[_owner];
     }
 
     /// @param _owner The address of the account owning tokens
     /// @param _spender The address of the account able to transfer the tokens
     /// @return Amount of remaining tokens allowed to spent
-    function allowance(address _owner, address _spender)
+    function allowance(address _owner, address _spender) external view returns (uint256) {
-        external
-        view
-        returns (uint256)
-    {
         return allowed[_owner][_spender];
     }
 }

contracts/erc20/contracts/src/LibERC20Token.sol

@@ -22,9 +22,8 @@ import "@0x/contracts-utils/contracts/src/LibRichErrors.sol";
 import "@0x/contracts-utils/contracts/src/LibBytes.sol";
 import "../src/interfaces/IERC20Token.sol";
 
-
 library LibERC20Token {
-    bytes constant private DECIMALS_CALL_DATA = hex"313ce567";
+    bytes private constant DECIMALS_CALL_DATA = hex"313ce567";
 
     /// @dev Calls `IERC20Token(token).approve()`.
     ///      Reverts if `false` is returned or if the return
@@ -36,14 +35,8 @@ library LibERC20Token {
         address token,
         address spender,
         uint256 allowance
-    )
+    ) internal {
-        internal
+        bytes memory callData = abi.encodeWithSelector(IERC20Token(0).approve.selector, spender, allowance);
-    {
-        bytes memory callData = abi.encodeWithSelector(
-            IERC20Token(0).approve.selector,
-            spender,
-            allowance
-        );
         _callWithOptionalBooleanResult(token, callData);
     }
 
@@ -58,9 +51,7 @@ library LibERC20Token {
         address token,
         address spender,
         uint256 amount
-    )
+    ) internal {
-        internal
-    {
         if (IERC20Token(token).allowance(address(this), spender) < amount) {
             approve(token, spender, uint256(-1));
         }
@@ -76,14 +67,8 @@ library LibERC20Token {
         address token,
         address to,
         uint256 amount
-    )
+    ) internal {
-        internal
+        bytes memory callData = abi.encodeWithSelector(IERC20Token(0).transfer.selector, to, amount);
-    {
-        bytes memory callData = abi.encodeWithSelector(
-            IERC20Token(0).transfer.selector,
-            to,
-            amount
-        );
         _callWithOptionalBooleanResult(token, callData);
     }
 
@@ -99,15 +84,8 @@ library LibERC20Token {
         address from,
         address to,
         uint256 amount
-    )
+    ) internal {
-        internal
+        bytes memory callData = abi.encodeWithSelector(IERC20Token(0).transferFrom.selector, from, to, amount);
-    {
-        bytes memory callData = abi.encodeWithSelector(
-            IERC20Token(0).transferFrom.selector,
-            from,
-            to,
-            amount
-        );
         _callWithOptionalBooleanResult(token, callData);
     }
 
@@ -115,11 +93,7 @@ library LibERC20Token {
     ///      Returns `18` if the call reverts.
     /// @param token The address of the token contract.
     /// @return tokenDecimals The number of decimals places for the token.
-    function decimals(address token)
+    function decimals(address token) internal view returns (uint8 tokenDecimals) {
-        internal
-        view
-        returns (uint8 tokenDecimals)
-    {
         tokenDecimals = 18;
         (bool didSucceed, bytes memory resultData) = token.staticcall(DECIMALS_CALL_DATA);
         if (didSucceed && resultData.length == 32) {
@@ -133,17 +107,13 @@ library LibERC20Token {
     /// @param owner The owner of the tokens.
     /// @param spender The address the spender.
     /// @return allowance The allowance for a token, owner, and spender.
-    function allowance(address token, address owner, address spender)
+    function allowance(
-        internal
+        address token,
-        view
+        address owner,
-        returns (uint256 allowance_)
+        address spender
-    {
+    ) internal view returns (uint256 allowance_) {
         (bool didSucceed, bytes memory resultData) = token.staticcall(
-            abi.encodeWithSelector(
+            abi.encodeWithSelector(IERC20Token(0).allowance.selector, owner, spender)
-                IERC20Token(0).allowance.selector,
-                owner,
-                spender
-            )
         );
         if (didSucceed && resultData.length == 32) {
             allowance_ = LibBytes.readUint256(resultData, 0);
@@ -155,16 +125,9 @@ library LibERC20Token {
     /// @param token The address of the token contract.
     /// @param owner The owner of the tokens.
     /// @return balance The token balance of an owner.
-    function balanceOf(address token, address owner)
+    function balanceOf(address token, address owner) internal view returns (uint256 balance) {
-        internal
-        view
-        returns (uint256 balance)
-    {
         (bool didSucceed, bytes memory resultData) = token.staticcall(
-            abi.encodeWithSelector(
+            abi.encodeWithSelector(IERC20Token(0).balanceOf.selector, owner)
-                IERC20Token(0).balanceOf.selector,
-                owner
-            )
         );
         if (didSucceed && resultData.length == 32) {
             balance = LibBytes.readUint256(resultData, 0);
@@ -176,12 +139,7 @@ library LibERC20Token {
     ///      was returned equal to `true`.
     /// @param target The call target.
     /// @param callData The abi-encoded call data.
-    function _callWithOptionalBooleanResult(
+    function _callWithOptionalBooleanResult(address target, bytes memory callData) private {
-        address target,
-        bytes memory callData
-    )
-        private
-    {
         (bool didSucceed, bytes memory resultData) = target.call(callData);
         if (didSucceed) {
             if (resultData.length == 0) {

contracts/erc20/contracts/src/MintableERC20Token.sol

@@ -21,41 +21,26 @@ pragma solidity ^0.5.9;
 import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
 import "./UnlimitedAllowanceERC20Token.sol";
 
-
+contract MintableERC20Token is UnlimitedAllowanceERC20Token {
-contract MintableERC20Token is
-    UnlimitedAllowanceERC20Token
-{
     using LibSafeMath for uint256;
 
     /// @dev Mints new tokens
     /// @param _to Address of the beneficiary that will own the minted token
     /// @param _value Amount of tokens to mint
-    function _mint(address _to, uint256 _value)
+    function _mint(address _to, uint256 _value) internal {
-        internal
-    {
         balances[_to] = _value.safeAdd(balances[_to]);
         _totalSupply = _totalSupply.safeAdd(_value);
 
-        emit Transfer(
+        emit Transfer(address(0), _to, _value);
-            address(0),
-            _to,
-            _value
-        );
     }
 
     /// @dev Mints new tokens
     /// @param _owner Owner of tokens that will be burned
     /// @param _value Amount of tokens to burn
-    function _burn(address _owner, uint256 _value)
+    function _burn(address _owner, uint256 _value) internal {
-        internal
-    {
         balances[_owner] = balances[_owner].safeSub(_value);
         _totalSupply = _totalSupply.safeSub(_value);
 
-        emit Transfer(
+        emit Transfer(_owner, address(0), _value);
-            _owner,
-            address(0),
-            _value
-        );
     }
 }

contracts/erc20/contracts/src/UnlimitedAllowanceERC20Token.sol

@@ -20,11 +20,8 @@ pragma solidity ^0.5.9;
 
 import "./ERC20Token.sol";
 
-
+contract UnlimitedAllowanceERC20Token is ERC20Token {
-contract UnlimitedAllowanceERC20Token is
+    uint256 internal constant MAX_UINT = 2**256 - 1;
-    ERC20Token
-{
-    uint256 constant internal MAX_UINT = 2**256 - 1;
 
     /// @dev ERC20 transferFrom, modified such that an allowance of MAX_UINT represents an unlimited allowance. See https://github.com/ethereum/EIPs/issues/717
     /// @param _from Address to transfer from.
@@ -35,23 +32,11 @@ contract UnlimitedAllowanceERC20Token is
         address _from,
         address _to,
         uint256 _value
-    )
+    ) external returns (bool) {
-        external
-        returns (bool)
-    {
         uint256 allowance = allowed[_from][msg.sender];
-        require(
+        require(balances[_from] >= _value, "ERC20_INSUFFICIENT_BALANCE");
-            balances[_from] >= _value,
+        require(allowance >= _value, "ERC20_INSUFFICIENT_ALLOWANCE");
-            "ERC20_INSUFFICIENT_BALANCE"
+        require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");
-        );
-        require(
-            allowance >= _value,
-            "ERC20_INSUFFICIENT_ALLOWANCE"
-        );
-        require(
-            balances[_to] + _value >= balances[_to],
-            "UINT256_OVERFLOW"
-        );
 
         balances[_to] += _value;
         balances[_from] -= _value;
@@ -59,11 +44,7 @@ contract UnlimitedAllowanceERC20Token is
             allowed[_from][msg.sender] -= _value;
         }
 
-        emit Transfer(
+        emit Transfer(_from, _to, _value);
-            _from,
-            _to,
-            _value
-        );
 
         return true;
     }

contracts/erc20/contracts/src/WETH9.sol

@@ -16,55 +16,57 @@
 // solhint-disable
 pragma solidity ^0.5.9;
 
-
 contract WETH9 {
-    string public name     = "Wrapped Ether";
+    string public name = "Wrapped Ether";
-    string public symbol   = "WETH";
+    string public symbol = "WETH";
-    uint8  public decimals = 18;
+    uint8 public decimals = 18;
 
-    event  Approval(address indexed _owner, address indexed _spender, uint _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
-    event  Transfer(address indexed _from, address indexed _to, uint _value);
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
-    event  Deposit(address indexed _owner, uint _value);
+    event Deposit(address indexed _owner, uint256 _value);
-    event  Withdrawal(address indexed _owner, uint _value);
+    event Withdrawal(address indexed _owner, uint256 _value);
 
-    mapping (address => uint)                       public  balanceOf;
+    mapping(address => uint256) public balanceOf;
-    mapping (address => mapping (address => uint))  public  allowance;
+    mapping(address => mapping(address => uint256)) public allowance;
 
     function() external payable {
         deposit();
     }
+
     function deposit() public payable {
         balanceOf[msg.sender] += msg.value;
         emit Deposit(msg.sender, msg.value);
     }
-    function withdraw(uint wad) public {
+
+    function withdraw(uint256 wad) public {
         require(balanceOf[msg.sender] >= wad);
         balanceOf[msg.sender] -= wad;
         msg.sender.transfer(wad);
         emit Withdrawal(msg.sender, wad);
     }
 
-    function totalSupply() public view returns (uint) {
+    function totalSupply() public view returns (uint256) {
         return address(this).balance;
     }
 
-    function approve(address guy, uint wad) public returns (bool) {
+    function approve(address guy, uint256 wad) public returns (bool) {
         allowance[msg.sender][guy] = wad;
         emit Approval(msg.sender, guy, wad);
         return true;
     }
 
-    function transfer(address dst, uint wad) public returns (bool) {
+    function transfer(address dst, uint256 wad) public returns (bool) {
         return transferFrom(msg.sender, dst, wad);
     }
 
-    function transferFrom(address src, address dst, uint wad)
+    function transferFrom(
-        public
+        address src,
-        returns (bool)
+        address dst,
-    {
+        uint256 wad
+    ) public returns (bool) {
         require(balanceOf[src] >= wad);
 
-        if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
+        if (src != msg.sender && allowance[src][msg.sender] != uint256(-1)) {
             require(allowance[src][msg.sender] >= wad);
             allowance[src][msg.sender] -= wad;
         }
@@ -78,7 +80,6 @@ contract WETH9 {
     }
 }
 
-
 /*
                     GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007

contracts/erc20/contracts/src/ZRXToken.sol

@@ -18,105 +18,111 @@
 
 pragma solidity 0.4.11;
 
-
 contract Token {
-
     /// @return total amount of tokens
-    function totalSupply() constant returns (uint supply) {}
+    function totalSupply() constant returns (uint256 supply) {}
 
     /// @param _owner The address from which the balance will be retrieved
     /// @return The balance
-    function balanceOf(address _owner) constant returns (uint balance) {}
+    function balanceOf(address _owner) constant returns (uint256 balance) {}
 
     /// @notice send `_value` token to `_to` from `msg.sender`
     /// @param _to The address of the recipient
     /// @param _value The amount of token to be transferred
     /// @return Whether the transfer was successful or not
-    function transfer(address _to, uint _value) returns (bool success) {}
+    function transfer(address _to, uint256 _value) returns (bool success) {}
 
     /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
     /// @param _from The address of the sender
     /// @param _to The address of the recipient
     /// @param _value The amount of token to be transferred
     /// @return Whether the transfer was successful or not
-    function transferFrom(address _from, address _to, uint _value) returns (bool success) {}
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _value
+    ) returns (bool success) {}
 
     /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
     /// @param _spender The address of the account able to transfer the tokens
     /// @param _value The amount of wei to be approved for transfer
     /// @return Whether the approval was successful or not
-    function approve(address _spender, uint _value) returns (bool success) {}
+    function approve(address _spender, uint256 _value) returns (bool success) {}
 
     /// @param _owner The address of the account owning tokens
     /// @param _spender The address of the account able to transfer the tokens
     /// @return Amount of remaining tokens allowed to spent
-    function allowance(address _owner, address _spender) constant returns (uint remaining) {}
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
 
-    event Transfer(address indexed _from, address indexed _to, uint _value);
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
-    event Approval(address indexed _owner, address indexed _spender, uint _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
 }
 
-
 contract ERC20Token is Token {
-
+    function transfer(address _to, uint256 _value) returns (bool) {
-    function transfer(address _to, uint _value) returns (bool) {
         //Default assumes totalSupply can't be over max (2^256 - 1).
         if (balances[msg.sender] >= _value && balances[_to] + _value >= balances[_to]) {
             balances[msg.sender] -= _value;
             balances[_to] += _value;
             Transfer(msg.sender, _to, _value);
             return true;
-        } else { return false; }
+        } else {
+            return false;
+        }
     }
 
-    function transferFrom(address _from, address _to, uint _value) returns (bool) {
+    function transferFrom(
-        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value >= balances[_to]) {
+        address _from,
+        address _to,
+        uint256 _value
+    ) returns (bool) {
+        if (
+            balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value >= balances[_to]
+        ) {
             balances[_to] += _value;
             balances[_from] -= _value;
             allowed[_from][msg.sender] -= _value;
             Transfer(_from, _to, _value);
             return true;
-        } else { return false; }
+        } else {
+            return false;
+        }
     }
 
-    function balanceOf(address _owner) constant returns (uint) {
+    function balanceOf(address _owner) constant returns (uint256) {
         return balances[_owner];
     }
 
-    function approve(address _spender, uint _value) returns (bool) {
+    function approve(address _spender, uint256 _value) returns (bool) {
         allowed[msg.sender][_spender] = _value;
         Approval(msg.sender, _spender, _value);
         return true;
     }
 
-    function allowance(address _owner, address _spender) constant returns (uint) {
+    function allowance(address _owner, address _spender) constant returns (uint256) {
         return allowed[_owner][_spender];
     }
 
-    mapping (address => uint) balances;
+    mapping(address => uint256) balances;
-    mapping (address => mapping (address => uint)) allowed;
+    mapping(address => mapping(address => uint256)) allowed;
-    uint public totalSupply;
+    uint256 public totalSupply;
 }
 
-
 contract UnlimitedAllowanceToken is ERC20Token {
-
+    uint256 constant MAX_UINT = 2**256 - 1;
-    uint constant MAX_UINT = 2**256 - 1;
 
     /// @dev ERC20 transferFrom, modified such that an allowance of MAX_UINT represents an unlimited allowance.
     /// @param _from Address to transfer from.
     /// @param _to Address to transfer to.
     /// @param _value Amount to transfer.
     /// @return Success of transfer.
-    function transferFrom(address _from, address _to, uint _value)
+    function transferFrom(
-        public
+        address _from,
-        returns (bool)
+        address _to,
-    {
+        uint256 _value
-        uint allowance = allowed[_from][msg.sender];
+    ) public returns (bool) {
-        if (balances[_from] >= _value
+        uint256 allowance = allowed[_from][msg.sender];
-            && allowance >= _value
+        if (balances[_from] >= _value && allowance >= _value && balances[_to] + _value >= balances[_to]) {
-            && balances[_to] + _value >= balances[_to]
-        ) {
             balances[_to] += _value;
             balances[_from] -= _value;
             if (allowance < MAX_UINT) {
@@ -130,21 +136,16 @@ contract UnlimitedAllowanceToken is ERC20Token {
     }
 }
 
-
+contract ZRXToken is UnlimitedAllowanceToken {
-contract ZRXToken is 
-    UnlimitedAllowanceToken
-{
-
     // solhint-disable const-name-snakecase
-    uint8 constant public decimals = 18;
+    uint8 public constant decimals = 18;
     uint256 public totalSupply = 10**27; // 1 billion tokens, 18 decimal places
-    string constant public name = "0x Protocol Token";
+    string public constant name = "0x Protocol Token";
-    string constant public symbol = "ZRX";
+    string public constant symbol = "ZRX";
+
     // solhint-enableconst-name-snakecase
 
-    function ZRXToken()
+    function ZRXToken() public {
-        public
-    {
         balances[msg.sender] = totalSupply;
     }
 }

contracts/erc20/contracts/src/interfaces/IERC20Token.sol

@@ -18,29 +18,17 @@
 
 pragma solidity ^0.5.9;
 
-
 contract IERC20Token {
-
     // solhint-disable no-simple-event-func-name
-    event Transfer(
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
-        address indexed _from,
-        address indexed _to,
-        uint256 _value
-    );
 
-    event Approval(
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
-        address indexed _owner,
-        address indexed _spender,
-        uint256 _value
-    );
 
     /// @dev send `value` token to `to` from `msg.sender`
     /// @param _to The address of the recipient
     /// @param _value The amount of token to be transferred
     /// @return True if transfer was successful
-    function transfer(address _to, uint256 _value)
+    function transfer(address _to, uint256 _value) external returns (bool);
-        external
-        returns (bool);
 
     /// @dev send `value` token to `to` from `from` on the condition it is approved by `from`
     /// @param _from The address of the sender
@@ -51,37 +39,24 @@ contract IERC20Token {
         address _from,
         address _to,
         uint256 _value
-    )
+    ) external returns (bool);
-        external
-        returns (bool);
 
     /// @dev `msg.sender` approves `_spender` to spend `_value` tokens
     /// @param _spender The address of the account able to transfer the tokens
     /// @param _value The amount of wei to be approved for transfer
     /// @return Always true if the call has enough gas to complete execution
-    function approve(address _spender, uint256 _value)
+    function approve(address _spender, uint256 _value) external returns (bool);
-        external
-        returns (bool);
 
     /// @dev Query total supply of token
     /// @return Total supply of token
-    function totalSupply()
+    function totalSupply() external view returns (uint256);
-        external
-        view
-        returns (uint256);
 
     /// @param _owner The address from which the balance will be retrieved
     /// @return Balance of owner
-    function balanceOf(address _owner)
+    function balanceOf(address _owner) external view returns (uint256);
-        external
-        view
-        returns (uint256);
 
     /// @param _owner The address of the account owning tokens
     /// @param _spender The address of the account able to transfer the tokens
     /// @return Amount of remaining tokens allowed to spent
-    function allowance(address _owner, address _spender)
+    function allowance(address _owner, address _spender) external view returns (uint256);
-        external
-        view
-        returns (uint256);
 }

contracts/erc20/contracts/src/interfaces/IEtherToken.sol

@@ -20,14 +20,8 @@ pragma solidity ^0.5.9;
 
 import "./IERC20Token.sol";
 
+contract IEtherToken is IERC20Token {
+    function deposit() public payable;
 
-contract IEtherToken is
+    function withdraw(uint256 amount) public;
-    IERC20Token
-{
-    function deposit()
-        public
-        payable;
-    
-    function withdraw(uint256 amount)
-        public;
 }

contracts/erc20/contracts/src/v06/IERC20TokenV06.sol

@@ -19,29 +19,17 @@
 
 pragma solidity ^0.6.5;
 
-
 interface IERC20TokenV06 {
-
     // solhint-disable no-simple-event-func-name
-    event Transfer(
+    event Transfer(address indexed from, address indexed to, uint256 value);
-        address indexed from,
-        address indexed to,
-        uint256 value
-    );
 
-    event Approval(
+    event Approval(address indexed owner, address indexed spender, uint256 value);
-        address indexed owner,
-        address indexed spender,
-        uint256 value
-    );
 
     /// @dev send `value` token to `to` from `msg.sender`
     /// @param to The address of the recipient
     /// @param value The amount of token to be transferred
     /// @return True if transfer was successful
-    function transfer(address to, uint256 value)
+    function transfer(address to, uint256 value) external returns (bool);
-        external
-        returns (bool);
 
     /// @dev send `value` token to `to` from `from` on the condition it is approved by `from`
     /// @param from The address of the sender
@@ -52,45 +40,29 @@ interface IERC20TokenV06 {
         address from,
         address to,
         uint256 value
-    )
+    ) external returns (bool);
-        external
-        returns (bool);
 
     /// @dev `msg.sender` approves `spender` to spend `value` tokens
     /// @param spender The address of the account able to transfer the tokens
     /// @param value The amount of wei to be approved for transfer
     /// @return Always true if the call has enough gas to complete execution
-    function approve(address spender, uint256 value)
+    function approve(address spender, uint256 value) external returns (bool);
-        external
-        returns (bool);
 
     /// @dev Query total supply of token
     /// @return Total supply of token
-    function totalSupply()
+    function totalSupply() external view returns (uint256);
-        external
-        view
-        returns (uint256);
 
     /// @dev Get the balance of `owner`.
     /// @param owner The address from which the balance will be retrieved
     /// @return Balance of owner
-    function balanceOf(address owner)
+    function balanceOf(address owner) external view returns (uint256);
-        external
-        view
-        returns (uint256);
 
     /// @dev Get the allowance for `spender` to spend from `owner`.
     /// @param owner The address of the account owning tokens
     /// @param spender The address of the account able to transfer the tokens
     /// @return Amount of remaining tokens allowed to spent
-    function allowance(address owner, address spender)
+    function allowance(address owner, address spender) external view returns (uint256);
-        external
-        view
-        returns (uint256);
 
     /// @dev Get the number of decimals this token has.
-    function decimals()
+    function decimals() external view returns (uint8);
-        external
-        view
-        returns (uint8);
 }

contracts/erc20/contracts/src/v06/IEtherTokenV06.sol

@@ -21,10 +21,7 @@ pragma solidity ^0.6.5;
 
 import "./IERC20TokenV06.sol";
 
-
+interface IEtherTokenV06 is IERC20TokenV06 {
-interface IEtherTokenV06 is
-    IERC20TokenV06
-{
     /// @dev Wrap ether.
     function deposit() external payable;
 

contracts/erc20/contracts/src/v06/LibERC20TokenV06.sol

@@ -23,9 +23,8 @@ import "@0x/contracts-utils/contracts/src/v06/errors/LibRichErrorsV06.sol";
 import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
 import "./IERC20TokenV06.sol";
 
-
 library LibERC20TokenV06 {
-    bytes constant private DECIMALS_CALL_DATA = hex"313ce567";
+    bytes private constant DECIMALS_CALL_DATA = hex"313ce567";
 
     /// @dev Calls `IERC20TokenV06(token).approve()`.
     ///      Reverts if the return data is invalid or the call reverts.
@@ -36,14 +35,8 @@ library LibERC20TokenV06 {
         IERC20TokenV06 token,
         address spender,
         uint256 allowance
-    )
+    ) internal {
-        internal
+        bytes memory callData = abi.encodeWithSelector(token.approve.selector, spender, allowance);
-    {
-        bytes memory callData = abi.encodeWithSelector(
-            token.approve.selector,
-            spender,
-            allowance
-        );
         _callWithOptionalBooleanResult(address(token), callData);
     }
 
@@ -57,9 +50,7 @@ library LibERC20TokenV06 {
         IERC20TokenV06 token,
         address spender,
         uint256 amount
-    )
+    ) internal {
-        internal
-    {
         if (token.allowance(address(this), spender) < amount) {
             compatApprove(token, spender, uint256(-1));
         }
@@ -74,14 +65,8 @@ library LibERC20TokenV06 {
         IERC20TokenV06 token,
         address to,
         uint256 amount
-    )
+    ) internal {
-        internal
+        bytes memory callData = abi.encodeWithSelector(token.transfer.selector, to, amount);
-    {
-        bytes memory callData = abi.encodeWithSelector(
-            token.transfer.selector,
-            to,
-            amount
-        );
         _callWithOptionalBooleanResult(address(token), callData);
     }
 
@@ -96,15 +81,8 @@ library LibERC20TokenV06 {
         address from,
         address to,
         uint256 amount
-    )
+    ) internal {
-        internal
+        bytes memory callData = abi.encodeWithSelector(token.transferFrom.selector, from, to, amount);
-    {
-        bytes memory callData = abi.encodeWithSelector(
-            token.transferFrom.selector,
-            from,
-            to,
-            amount
-        );
         _callWithOptionalBooleanResult(address(token), callData);
     }
 
@@ -112,11 +90,7 @@ library LibERC20TokenV06 {
     ///      Returns `18` if the call reverts.
     /// @param token The address of the token contract.
     /// @return tokenDecimals The number of decimals places for the token.
-    function compatDecimals(IERC20TokenV06 token)
+    function compatDecimals(IERC20TokenV06 token) internal view returns (uint8 tokenDecimals) {
-        internal
-        view
-        returns (uint8 tokenDecimals)
-    {
         tokenDecimals = 18;
         (bool didSucceed, bytes memory resultData) = address(token).staticcall(DECIMALS_CALL_DATA);
         if (didSucceed && resultData.length >= 32) {
@@ -130,17 +104,13 @@ library LibERC20TokenV06 {
     /// @param owner The owner of the tokens.
     /// @param spender The address the spender.
     /// @return allowance_ The allowance for a token, owner, and spender.
-    function compatAllowance(IERC20TokenV06 token, address owner, address spender)
+    function compatAllowance(
-        internal
+        IERC20TokenV06 token,
-        view
+        address owner,
-        returns (uint256 allowance_)
+        address spender
-    {
+    ) internal view returns (uint256 allowance_) {
         (bool didSucceed, bytes memory resultData) = address(token).staticcall(
-            abi.encodeWithSelector(
+            abi.encodeWithSelector(token.allowance.selector, owner, spender)
-                token.allowance.selector,
-                owner,
-                spender
-            )
         );
         if (didSucceed && resultData.length >= 32) {
             allowance_ = LibBytesV06.readUint256(resultData, 0);
@@ -152,16 +122,9 @@ library LibERC20TokenV06 {
     /// @param token The address of the token contract.
     /// @param owner The owner of the tokens.
     /// @return balance The token balance of an owner.
-    function compatBalanceOf(IERC20TokenV06 token, address owner)
+    function compatBalanceOf(IERC20TokenV06 token, address owner) internal view returns (uint256 balance) {
-        internal
-        view
-        returns (uint256 balance)
-    {
         (bool didSucceed, bytes memory resultData) = address(token).staticcall(
-            abi.encodeWithSelector(
+            abi.encodeWithSelector(token.balanceOf.selector, owner)
-                token.balanceOf.selector,
-                owner
-            )
         );
         if (didSucceed && resultData.length >= 32) {
             balance = LibBytesV06.readUint256(resultData, 0);
@@ -173,12 +136,7 @@ library LibERC20TokenV06 {
     ///      was returned equal to `true`.
     /// @param target The call target.
     /// @param callData The abi-encoded call data.
-    function _callWithOptionalBooleanResult(
+    function _callWithOptionalBooleanResult(address target, bytes memory callData) private {
-        address target,
-        bytes memory callData
-    )
-        private
-    {
         (bool didSucceed, bytes memory resultData) = target.call(callData);
         // Revert if the call reverted.
         if (!didSucceed) {
@@ -188,7 +146,9 @@ library LibERC20TokenV06 {
         // does not return a boolean. Check that it at least contains code.
         if (resultData.length == 0) {
             uint256 size;
-            assembly { size := extcodesize(target) }
+            assembly {
+                size := extcodesize(target)
+            }
             require(size > 0, "invalid token address, contains no code");
             return;
         }

contracts/erc20/contracts/test/DummyERC20Token.sol

@@ -22,11 +22,7 @@ import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
 import "@0x/contracts-utils/contracts/src/Ownable.sol";
 import "../src/MintableERC20Token.sol";
 
-
+contract DummyERC20Token is Ownable, MintableERC20Token {
-contract DummyERC20Token is
-    Ownable,
-    MintableERC20Token
-{
     using LibSafeMath for uint256;
 
     string public name;
@@ -34,14 +30,12 @@ contract DummyERC20Token is
     uint256 public decimals;
     uint256 public constant MAX_MINT_AMOUNT = 10000000000000000000000;
 
-    constructor (
+    constructor(
         string memory _name,
         string memory _symbol,
         uint256 _decimals,
         uint256 _totalSupply
-    )
+    ) public {
-        public
-    {
         name = _name;
         symbol = _symbol;
         decimals = _decimals;
@@ -52,10 +46,7 @@ contract DummyERC20Token is
     /// @dev Sets the balance of target address
     /// @param _target Address or which balance will be updated
     /// @param _value New balance of target address
-    function setBalance(address _target, uint256 _value)
+    function setBalance(address _target, uint256 _value) external onlyOwner {
-        external
-        onlyOwner
-    {
         uint256 currBalance = balances[_target];
         if (_value < currBalance) {
             _totalSupply = _totalSupply.safeSub(currBalance.safeSub(_value));
@@ -67,13 +58,8 @@ contract DummyERC20Token is
 
     /// @dev Mints new tokens for sender
     /// @param _value Amount of tokens to mint
-    function mint(uint256 _value)
+    function mint(uint256 _value) external {
-        external
+        require(_value <= MAX_MINT_AMOUNT, "VALUE_TOO_LARGE");
-    {
-        require(
-            _value <= MAX_MINT_AMOUNT,
-            "VALUE_TOO_LARGE"
-        );
 
         _mint(msg.sender, _value);
     }

contracts/erc20/contracts/test/DummyMultipleReturnERC20Token.sol

@@ -20,25 +20,14 @@ pragma solidity ^0.5.5;
 
 import "./DummyERC20Token.sol";
 
-
 // solhint-disable no-empty-blocks
-contract DummyMultipleReturnERC20Token is
+contract DummyMultipleReturnERC20Token is DummyERC20Token {
-    DummyERC20Token
+    constructor(
-{
-    constructor (
         string memory _name,
         string memory _symbol,
         uint256 _decimals,
         uint256 _totalSupply
-    )
+    ) public DummyERC20Token(_name, _symbol, _decimals, _totalSupply) {}
-        public
-        DummyERC20Token(
-            _name,
-            _symbol,
-            _decimals,
-            _totalSupply
-        )
-    {}
 
     /// @dev send `value` token to `to` from `from` on the condition it is approved by `from`
     /// @param _from The address of the sender
@@ -48,15 +37,8 @@ contract DummyMultipleReturnERC20Token is
         address _from,
         address _to,
         uint256 _value
-    )
+    ) external returns (bool) {
-        external
+        emit Transfer(_from, _to, _value);
-        returns (bool)
-    {
-        emit Transfer(
-            _from,
-            _to,
-            _value
-        );
 
         // HACK: This contract will not compile if we remove `returns (bool)`, so we manually return 64 bytes (equiavalent to true, true)
         assembly {
@@ -66,4 +48,3 @@ contract DummyMultipleReturnERC20Token is
         }
     }
 }
-

contracts/erc20/contracts/test/DummyNoReturnERC20Token.sol

@@ -20,50 +20,26 @@ pragma solidity ^0.5.5;
 
 import "./DummyERC20Token.sol";
 
-
 // solhint-disable no-empty-blocks
-contract DummyNoReturnERC20Token is
+contract DummyNoReturnERC20Token is DummyERC20Token {
-    DummyERC20Token
+    constructor(
-{
-    constructor (
         string memory _name,
         string memory _symbol,
         uint256 _decimals,
         uint256 _totalSupply
-    )
+    ) public DummyERC20Token(_name, _symbol, _decimals, _totalSupply) {}
-        public
-        DummyERC20Token(
-            _name,
-            _symbol,
-            _decimals,
-            _totalSupply
-        )
-    {}
 
     /// @dev send `value` token to `to` from `msg.sender`
     /// @param _to The address of the recipient
     /// @param _value The amount of token to be transferred
-    function transfer(address _to, uint256 _value)
+    function transfer(address _to, uint256 _value) external returns (bool) {
-        external
+        require(balances[msg.sender] >= _value, "ERC20_INSUFFICIENT_BALANCE");
-        returns (bool)
+        require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");
-    {
-        require(
-            balances[msg.sender] >= _value,
-            "ERC20_INSUFFICIENT_BALANCE"
-        );
-        require(
-            balances[_to] + _value >= balances[_to],
-            "UINT256_OVERFLOW"
-        );
 
         balances[msg.sender] -= _value;
         balances[_to] += _value;
 
-        emit Transfer(
+        emit Transfer(msg.sender, _to, _value);
-            msg.sender,
-            _to,
-            _value
-        );
 
         // HACK: This contract will not compile if we remove `returns (bool)`, so we manually return no data
         assembly {
@@ -79,32 +55,16 @@ contract DummyNoReturnERC20Token is
         address _from,
         address _to,
         uint256 _value
-    )
+    ) external returns (bool) {
-        external
+        require(balances[_from] >= _value, "ERC20_INSUFFICIENT_BALANCE");
-        returns (bool)
+        require(allowed[_from][msg.sender] >= _value, "ERC20_INSUFFICIENT_ALLOWANCE");
-    {
+        require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");
-        require(
-            balances[_from] >= _value,
-            "ERC20_INSUFFICIENT_BALANCE"
-        );
-        require(
-            allowed[_from][msg.sender] >= _value,
-            "ERC20_INSUFFICIENT_ALLOWANCE"
-        );
-        require(
-            balances[_to] + _value >= balances[_to],
-            "UINT256_OVERFLOW"
-        );
 
         balances[_to] += _value;
         balances[_from] -= _value;
         allowed[_from][msg.sender] -= _value;
 
-        emit Transfer(
+        emit Transfer(_from, _to, _value);
-            _from,
-            _to,
-            _value
-        );
 
         // HACK: This contract will not compile if we remove `returns (bool)`, so we manually return no data
         assembly {
@@ -112,4 +72,3 @@ contract DummyNoReturnERC20Token is
         }
     }
 }
-

contracts/erc20/contracts/test/TestLibERC20Token.sol

@@ -21,9 +21,7 @@ pragma solidity ^0.5.9;
 import "../src/LibERC20Token.sol";
 import "./TestLibERC20TokenTarget.sol";
 
-
 contract TestLibERC20Token {
-
     TestLibERC20TokenTarget public target;
 
     constructor() public {
@@ -36,9 +34,7 @@ contract TestLibERC20Token {
         bytes calldata returnData,
         address spender,
         uint256 allowance
-    )
+    ) external {
-        external
-    {
         target.setBehavior(shouldRevert, revertData, returnData);
         LibERC20Token.approve(address(target), spender, allowance);
     }
@@ -49,9 +45,7 @@ contract TestLibERC20Token {
         bytes calldata returnData,
         address to,
         uint256 amount
-    )
+    ) external {
-        external
-    {
         target.setBehavior(shouldRevert, revertData, returnData);
         LibERC20Token.transfer(address(target), to, amount);
     }
@@ -63,9 +57,7 @@ contract TestLibERC20Token {
         address from,
         address to,
         uint256 amount
-    )
+    ) external {
-        external
-    {
         target.setBehavior(shouldRevert, revertData, returnData);
         LibERC20Token.transferFrom(address(target), from, to, amount);
     }
@@ -74,10 +66,7 @@ contract TestLibERC20Token {
         bool shouldRevert,
         bytes calldata revertData,
         bytes calldata returnData
-    )
+    ) external returns (uint8) {
-        external
-        returns (uint8)
-    {
         target.setBehavior(shouldRevert, revertData, returnData);
         return LibERC20Token.decimals(address(target));
     }

contracts/erc20/contracts/test/TestLibERC20TokenTarget.sol

@@ -18,24 +18,12 @@
 
 pragma solidity ^0.5.9;
 
-
 contract TestLibERC20TokenTarget {
+    event ApproveCalled(address spender, uint256 allowance);
 
-    event ApproveCalled(
+    event TransferCalled(address to, uint256 amount);
-        address spender,
-        uint256 allowance
-    );
 
-    event TransferCalled(
+    event TransferFromCalled(address from, address to, uint256 amount);
-        address to,
-        uint256 amount
-    );
-
-    event TransferFromCalled(
-        address from,
-        address to,
-        uint256 amount
-    );
 
     bool private _shouldRevert;
     bytes private _revertData;
@@ -45,32 +33,18 @@ contract TestLibERC20TokenTarget {
         bool shouldRevert,
         bytes calldata revertData,
         bytes calldata returnData
-    )
+    ) external {
-        external
-    {
         _shouldRevert = shouldRevert;
         _revertData = revertData;
         _returnData = returnData;
     }
 
-    function approve(
+    function approve(address spender, uint256 allowance) external returns (bool) {
-        address spender,
-        uint256 allowance
-    )
-        external
-        returns (bool)
-    {
         emit ApproveCalled(spender, allowance);
         _execute();
     }
 
-    function transfer(
+    function transfer(address to, uint256 amount) external returns (bool) {
-        address to,
-        uint256 amount
-    )
-        external
-        returns (bool)
-    {
         emit TransferCalled(to, amount);
         _execute();
     }
@@ -79,28 +53,25 @@ contract TestLibERC20TokenTarget {
         address from,
         address to,
         uint256 amount
-    )
+    ) external returns (bool) {
-        external
-        returns (bool)
-    {
         emit TransferFromCalled(from, to, amount);
         _execute();
     }
 
-    function decimals()
+    function decimals() external view returns (uint8) {
-        external
-        view
-        returns (uint8)
-    {
         _execute();
     }
 
     function _execute() private view {
         if (_shouldRevert) {
             bytes memory revertData = _revertData;
-            assembly { revert(add(revertData, 0x20), mload(revertData)) }
+            assembly {
+                revert(add(revertData, 0x20), mload(revertData))
+            }
         }
         bytes memory returnData = _returnData;
-        assembly { return(add(returnData, 0x20), mload(returnData)) }
+        assembly {
+            return(add(returnData, 0x20), mload(returnData))
+        }
     }
 }

contracts/erc20/contracts/test/UntransferrableDummyERC20Token.sol

@@ -20,26 +20,15 @@ pragma solidity ^0.5.5;
 
 import "./DummyERC20Token.sol";
 
-
 // solhint-disable no-empty-blocks
 // solhint-disable no-unused-vars
-contract UntransferrableDummyERC20Token is
+contract UntransferrableDummyERC20Token is DummyERC20Token {
-    DummyERC20Token
+    constructor(
-{
-    constructor (
         string memory _name,
         string memory _symbol,
         uint256 _decimals,
         uint256 _totalSupply
-    )
+    ) public DummyERC20Token(_name, _symbol, _decimals, _totalSupply) {}
-        public
-        DummyERC20Token(
-            _name,
-            _symbol,
-            _decimals,
-            _totalSupply
-        )
-    {}
 
     /// @dev send `value` token to `to` from `from` on the condition it is approved by `from`
     /// @param _from The address of the sender
@@ -49,14 +38,7 @@ contract UntransferrableDummyERC20Token is
         address _from,
         address _to,
         uint256 _value
-    )
+    ) external returns (bool) {
-        external
+        require(false, "TRANSFER_DISABLED");
-        returns (bool)
-    {
-        require(
-            false,
-            "TRANSFER_DISABLED"
-        );
     }
 }
-

contracts/erc20/src/artifacts.ts

@@ -15,7 +15,7 @@ export const artifacts = {
     DummyERC20Token: DummyERC20Token as ContractArtifact,
     ERC20Token: ERC20Token as ContractArtifact,
     WETH9: WETH9 as ContractArtifact,
-    ZRXToken: (ZRXToken as any) as ContractArtifact,
+    ZRXToken: ZRXToken as any as ContractArtifact,
     DummyNoReturnERC20Token: DummyNoReturnERC20Token as ContractArtifact,
     DummyMultipleReturnERC20Token: DummyMultipleReturnERC20Token as ContractArtifact,
 };

contracts/erc20/test/artifacts.ts

@@ -28,7 +28,7 @@ export const artifacts = {
     MintableERC20Token: MintableERC20Token as ContractArtifact,
     UnlimitedAllowanceERC20Token: UnlimitedAllowanceERC20Token as ContractArtifact,
     WETH9: WETH9 as ContractArtifact,
-    ZRXToken: (ZRXToken as any) as ContractArtifact,
+    ZRXToken: ZRXToken as any as ContractArtifact,
     IERC20Token: IERC20Token as ContractArtifact,
     IEtherToken: IEtherToken as ContractArtifact,
     IERC20TokenV06: IERC20TokenV06 as ContractArtifact,

contracts/treasury/contracts/external/ISablier.sol

@@ -50,9 +50,13 @@ interface ISablier {
             uint256 ratePerSecond
         );
 
-    function createStream(address recipient, uint256 deposit, address tokenAddress, uint256 startTime, uint256 stopTime)
+    function createStream(
-        external
+        address recipient,
-        returns (uint256 streamId);
+        uint256 deposit,
+        address tokenAddress,
+        uint256 startTime,
+        uint256 stopTime
+    ) external returns (uint256 streamId);
 
     function withdrawFromStream(uint256 streamId, uint256 funds) external returns (bool);
 

contracts/treasury/contracts/src/DefaultPoolOperator.sol

@@ -23,7 +23,6 @@ pragma experimental ABIEncoderV2;
 import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
 import "./IStaking.sol";
 
-
 contract DefaultPoolOperator {
     // Immutables
     IStaking public immutable stakingProxy;
@@ -33,16 +32,11 @@ contract DefaultPoolOperator {
     /// @dev Initializes this contract and creates a staking pool.
     /// @param stakingProxy_ The 0x staking proxy contract.
     /// @param weth_ The WETH token contract.
-    constructor(
+    constructor(IStaking stakingProxy_, IERC20TokenV06 weth_) public {
-        IStaking stakingProxy_,
-        IERC20TokenV06 weth_
-    )
-        public
-    {
         stakingProxy = stakingProxy_;
         weth = weth_;
         // operator share = 100%
-        poolId = stakingProxy_.createStakingPool(10 ** 6, false);
+        poolId = stakingProxy_.createStakingPool(10**6, false);
     }
 
     /// @dev Sends this contract's entire WETH balance to the
@@ -51,9 +45,7 @@ contract DefaultPoolOperator {
     ///      market making for some reason, thus earning this contract
     ///      some staking rewards. Note that anyone can call this
     ///      function at any time.
-    function returnStakingRewards()
+    function returnStakingRewards() external {
-        external
-    {
         uint256 wethBalance = weth.balanceOf(address(this));
         weth.transfer(address(stakingProxy), wethBalance);
     }

contracts/treasury/contracts/src/IStaking.sol

@@ -20,7 +20,6 @@
 pragma solidity ^0.6.12;
 pragma experimental ABIEncoderV2;
 
-
 interface IStaking {
     /// @dev Statuses that stake can exist in.
     ///      Any stake can be (re)delegated effective at the next epoch
@@ -55,54 +54,34 @@ interface IStaking {
     /// @param operatorShare Portion of rewards owned by the operator, in ppm.
     /// @param addOperatorAsMaker Adds operator to the created pool as a maker for convenience iff true.
     /// @return poolId The unique pool id generated for this pool.
-    function createStakingPool(uint32 operatorShare, bool addOperatorAsMaker)
+    function createStakingPool(uint32 operatorShare, bool addOperatorAsMaker) external returns (bytes32 poolId);
-        external
-        returns (bytes32 poolId);
 
     /// @dev Returns the current staking epoch number.
     /// @return epoch The current epoch.
-    function currentEpoch()
+    function currentEpoch() external view returns (uint256 epoch);
-        external
-        view
-        returns (uint256 epoch);
 
     /// @dev Returns the time (in seconds) at which the current staking epoch started.
     /// @return startTime The start time of the current epoch, in seconds.
-    function currentEpochStartTimeInSeconds()
+    function currentEpochStartTimeInSeconds() external view returns (uint256 startTime);
-        external
-        view
-        returns (uint256 startTime);
 
     /// @dev Returns the duration of an epoch in seconds. This value can be updated.
     /// @return duration The duration of an epoch, in seconds.
-    function epochDurationInSeconds()
+    function epochDurationInSeconds() external view returns (uint256 duration);
-        external
-        view
-        returns (uint256 duration);
 
     /// @dev Returns a staking pool
     /// @param poolId Unique id of pool.
-    function getStakingPool(bytes32 poolId)
+    function getStakingPool(bytes32 poolId) external view returns (Pool memory);
-        external
-        view
-        returns (Pool memory);
 
     /// @dev Gets global stake for a given status.
     /// @param stakeStatus UNDELEGATED or DELEGATED
     /// @return balance Global stake for given status.
-    function getGlobalStakeByStatus(StakeStatus stakeStatus)
+    function getGlobalStakeByStatus(StakeStatus stakeStatus) external view returns (StoredBalance memory balance);
-        external
-        view
-        returns (StoredBalance memory balance);
 
     /// @dev Gets an owner's stake balances by status.
     /// @param staker Owner of stake.
     /// @param stakeStatus UNDELEGATED or DELEGATED
     /// @return balance Owner's stake balances for given status.
-    function getOwnerStakeByStatus(
+    function getOwnerStakeByStatus(address staker, StakeStatus stakeStatus)
-        address staker,
-        StakeStatus stakeStatus
-    )
         external
         view
         returns (StoredBalance memory balance);
@@ -111,10 +90,7 @@ interface IStaking {
     ///      across all members.
     /// @param poolId Unique Id of pool.
     /// @return balance Total stake delegated to pool.
-    function getTotalStakeDelegatedToPool(bytes32 poolId)
+    function getTotalStakeDelegatedToPool(bytes32 poolId) external view returns (StoredBalance memory balance);
-        external
-        view
-        returns (StoredBalance memory balance);
 
     /// @dev Returns the stake delegated to a specific staking pool, by a given staker.
     /// @param staker of stake.

contracts/treasury/contracts/src/IZrxTreasury.sol

@@ -23,9 +23,7 @@ pragma experimental ABIEncoderV2;
 import "./DefaultPoolOperator.sol";
 import "./IStaking.sol";
 
-
 interface IZrxTreasury {
-
     struct TreasuryParameters {
         uint256 votingPeriod;
         uint256 proposalThreshold;
@@ -57,45 +55,21 @@ interface IZrxTreasury {
         string description
     );
 
-    event VoteCast(
+    event VoteCast(address voter, bytes32[] operatedPoolIds, uint256 proposalId, bool support, uint256 votingPower);
-        address voter,
-        bytes32[] operatedPoolIds,
-        uint256 proposalId,
-        bool support,
-        uint256 votingPower
-    );
 
     event ProposalExecuted(uint256 proposalId);
 
-    function stakingProxy()
+    function stakingProxy() external view returns (IStaking);
-        external
-        view
-        returns (IStaking);
 
-    function defaultPoolOperator()
+    function defaultPoolOperator() external view returns (DefaultPoolOperator);
-        external
-        view
-        returns (DefaultPoolOperator);
 
-    function defaultPoolId()
+    function defaultPoolId() external view returns (bytes32);
-        external
-        view
-        returns (bytes32);
 
-    function votingPeriod()
+    function votingPeriod() external view returns (uint256);
-        external
-        view
-        returns (uint256);
 
-    function proposalThreshold()
+    function proposalThreshold() external view returns (uint256);
-        external
-        view
-        returns (uint256);
 
-    function quorumThreshold()
+    function quorumThreshold() external view returns (uint256);
-        external
-        view
-        returns (uint256);
 
     /// @dev Updates the proposal and quorum thresholds to the given
     ///      values. Note that this function is only callable by the
@@ -103,11 +77,7 @@ interface IZrxTreasury {
     ///      updated via a successful treasury proposal.
     /// @param newProposalThreshold The new value for the proposal threshold.
     /// @param newQuorumThreshold The new value for the quorum threshold.
-    function updateThresholds(
+    function updateThresholds(uint256 newProposalThreshold, uint256 newQuorumThreshold) external;
-        uint256 newProposalThreshold,
-        uint256 newQuorumThreshold
-    )
-        external;
 
     /// @dev Creates a proposal to send ZRX from this treasury on the
     ///      the given actions. Must have at least `proposalThreshold`
@@ -131,9 +101,7 @@ interface IZrxTreasury {
         uint256 executionEpoch,
         string calldata description,
         bytes32[] calldata operatedPoolIds
-    )
+    ) external returns (uint256 proposalId);
-        external
-        returns (uint256 proposalId);
 
     /// @dev Casts a vote for the given proposal. Only callable
     ///      during the voting period for that proposal.
@@ -148,8 +116,7 @@ interface IZrxTreasury {
         uint256 proposalId,
         bool support,
         bytes32[] calldata operatedPoolIds
-    )
+    ) external;
-        external;
 
     /// @dev Casts a vote for the given proposal, by signature.
     ///      Only callable during the voting period for that proposal.
@@ -170,23 +137,17 @@ interface IZrxTreasury {
         uint8 v,
         bytes32 r,
         bytes32 s
-    )
+    ) external;
-        external;
 
     /// @dev Executes a proposal that has passed and is
     ///      currently executable.
     /// @param proposalId The ID of the proposal to execute.
     /// @param actions Actions associated with the proposal to execute.
-    function execute(uint256 proposalId, ProposedAction[] memory actions)
+    function execute(uint256 proposalId, ProposedAction[] memory actions) external payable;
-        external
-        payable;
 
     /// @dev Returns the total number of proposals.
     /// @return count The number of proposals.
-    function proposalCount()
+    function proposalCount() external view returns (uint256 count);
-        external
-        view
-        returns (uint256 count);
 
     /// @dev Computes the current voting power of the given account.
     ///      Voting power is equal to:

contracts/treasury/contracts/src/ZrxTreasury.sol

@@ -26,10 +26,7 @@ import "@0x/contracts-utils/contracts/src/v06/errors/LibRichErrorsV06.sol";
 import "@0x/contracts-zero-ex/contracts/src/features/libs/LibSignature.sol";
 import "./IZrxTreasury.sol";
 
-
+contract ZrxTreasury is IZrxTreasury {
-contract ZrxTreasury is
-    IZrxTreasury
-{
     using LibSafeMathV06 for uint256;
     using LibRichErrorsV06 for bytes;
     using LibBytesV06 for bytes;
@@ -41,10 +38,12 @@ contract ZrxTreasury is
     string private constant CONTRACT_VERSION = "1.0.0";
 
     /// The EIP-712 typehash for the contract's domain
-    bytes32 private constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
+    bytes32 private constant DOMAIN_TYPEHASH =
+        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
 
     /// The EIP-712 typehash for the vote struct
-    bytes32 private constant VOTE_TYPEHASH = keccak256("TreasuryVote(uint256 proposalId,bool support,bytes32[] operatedPoolIds)");
+    bytes32 private constant VOTE_TYPEHASH =
+        keccak256("TreasuryVote(uint256 proposalId,bool support,bytes32[] operatedPoolIds)");
 
     // Immutables
     IStaking public immutable override stakingProxy;
@@ -58,22 +57,14 @@ contract ZrxTreasury is
 
     // Storage
     Proposal[] public proposals;
-    mapping (uint256 => mapping (address => bool)) public hasVoted;
+    mapping(uint256 => mapping(address => bool)) public hasVoted;
 
     /// @dev Initializes the ZRX treasury and creates the default
     ///      staking pool.
     /// @param stakingProxy_ The 0x staking proxy contract.
     /// @param params Immutable treasury parameters.
-    constructor(
+    constructor(IStaking stakingProxy_, TreasuryParameters memory params) public {
-        IStaking stakingProxy_,
+        require(params.votingPeriod < stakingProxy_.epochDurationInSeconds(), "VOTING_PERIOD_TOO_LONG");
-        TreasuryParameters memory params
-    )
-        public
-    {
-        require(
-            params.votingPeriod < stakingProxy_.epochDurationInSeconds(),
-            "VOTING_PERIOD_TOO_LONG"
-        );
         stakingProxy = stakingProxy_;
         votingPeriod = params.votingPeriod;
         proposalThreshold = params.proposalThreshold;
@@ -95,6 +86,7 @@ contract ZrxTreasury is
     // solhint-disable
     /// @dev Allows this contract to receive ether.
     receive() external payable {}
+
     // solhint-enable
 
     /// @dev Updates the proposal and quorum thresholds to the given
@@ -103,13 +95,7 @@ contract ZrxTreasury is
     ///      updated via a successful treasury proposal.
     /// @param newProposalThreshold The new value for the proposal threshold.
     /// @param newQuorumThreshold The new value for the quorum threshold.
-    function updateThresholds(
+    function updateThresholds(uint256 newProposalThreshold, uint256 newQuorumThreshold) external override {
-        uint256 newProposalThreshold,
-        uint256 newQuorumThreshold
-    )
-        external
-        override
-    {
         require(msg.sender == address(this), "updateThresholds/ONLY_SELF");
         proposalThreshold = newProposalThreshold;
         quorumThreshold = newQuorumThreshold;
@@ -137,24 +123,11 @@ contract ZrxTreasury is
         uint256 executionEpoch,
         string memory description,
         bytes32[] memory operatedPoolIds
-    )
+    ) public override returns (uint256 proposalId) {
-        public
+        require(getVotingPower(msg.sender, operatedPoolIds) >= proposalThreshold, "propose/INSUFFICIENT_VOTING_POWER");
-        override
+        require(actions.length > 0, "propose/NO_ACTIONS_PROPOSED");
-        returns (uint256 proposalId)
-    {
-        require(
-            getVotingPower(msg.sender, operatedPoolIds) >= proposalThreshold,
-            "propose/INSUFFICIENT_VOTING_POWER"
-        );
-        require(
-            actions.length > 0,
-            "propose/NO_ACTIONS_PROPOSED"
-        );
         uint256 currentEpoch = stakingProxy.currentEpoch();
-        require(
+        require(executionEpoch >= currentEpoch + 2, "propose/INVALID_EXECUTION_EPOCH");
-            executionEpoch >= currentEpoch + 2,
-            "propose/INVALID_EXECUTION_EPOCH"
-        );
 
         proposalId = proposalCount();
         Proposal storage newProposal = proposals.push();
@@ -162,14 +135,7 @@ contract ZrxTreasury is
         newProposal.executionEpoch = executionEpoch;
         newProposal.voteEpoch = currentEpoch + 2;
 
-        emit ProposalCreated(
+        emit ProposalCreated(msg.sender, operatedPoolIds, proposalId, actions, executionEpoch, description);
-            msg.sender,
-            operatedPoolIds,
-            proposalId,
-            actions,
-            executionEpoch,
-            description
-        );
     }
 
     /// @dev Casts a vote for the given proposal. Only callable
@@ -185,10 +151,7 @@ contract ZrxTreasury is
         uint256 proposalId,
         bool support,
         bytes32[] memory operatedPoolIds
-    )
+    ) public override {
-        public
-        override
-    {
         return _castVote(msg.sender, proposalId, support, operatedPoolIds);
     }
 
@@ -211,10 +174,7 @@ contract ZrxTreasury is
         uint8 v,
         bytes32 r,
         bytes32 s
-    )
+    ) public override {
-        public
-        override
-    {
         bytes32 structHash = keccak256(
             abi.encode(VOTE_TYPEHASH, proposalId, support, keccak256(abi.encodePacked(operatedPoolIds)))
         );
@@ -228,11 +188,7 @@ contract ZrxTreasury is
     ///      currently executable.
     /// @param proposalId The ID of the proposal to execute.
     /// @param actions Actions associated with the proposal to execute.
-    function execute(uint256 proposalId, ProposedAction[] memory actions)
+    function execute(uint256 proposalId, ProposedAction[] memory actions) public payable override {
-        public
-        payable
-        override
-    {
         if (proposalId >= proposalCount()) {
             revert("execute/INVALID_PROPOSAL_ID");
         }
@@ -244,10 +200,7 @@ contract ZrxTreasury is
         for (uint256 i = 0; i != actions.length; i++) {
             ProposedAction memory action = actions[i];
             (bool didSucceed, ) = action.target.call{value: action.value}(action.data);
-            require(
+            require(didSucceed, "execute/ACTION_EXECUTION_FAILED");
-                didSucceed,
-                "execute/ACTION_EXECUTION_FAILED"
-            );
         }
 
         emit ProposalExecuted(proposalId);
@@ -255,12 +208,7 @@ contract ZrxTreasury is
 
     /// @dev Returns the total number of proposals.
     /// @return count The number of proposals.
-    function proposalCount()
+    function proposalCount() public view override returns (uint256 count) {
-        public
-        override
-        view
-        returns (uint256 count)
-    {
         return proposals.length;
     }
 
@@ -276,39 +224,29 @@ contract ZrxTreasury is
     /// @return votingPower The current voting power of the given account.
     function getVotingPower(address account, bytes32[] memory operatedPoolIds)
         public
-        override
         view
+        override
         returns (uint256 votingPower)
     {
-        uint256 delegatedBalance = stakingProxy.getOwnerStakeByStatus(
+        uint256 delegatedBalance = stakingProxy
-            account,
+            .getOwnerStakeByStatus(account, IStaking.StakeStatus.DELEGATED)
-            IStaking.StakeStatus.DELEGATED
+            .currentEpochBalance;
-        ).currentEpochBalance;
+        uint256 balanceDelegatedToDefaultPool = stakingProxy
-        uint256 balanceDelegatedToDefaultPool = stakingProxy.getStakeDelegatedToPoolByOwner(
+            .getStakeDelegatedToPoolByOwner(account, defaultPoolId)
-            account,
+            .currentEpochBalance;
-            defaultPoolId
-        ).currentEpochBalance;
 
         // Voting power for ZRX delegated to the default pool is not diluted,
         // so we double-count the balance delegated to the default pool before
         // dividing by 2.
-        votingPower = delegatedBalance
+        votingPower = delegatedBalance.safeAdd(balanceDelegatedToDefaultPool).safeDiv(2);
-            .safeAdd(balanceDelegatedToDefaultPool)
-            .safeDiv(2);
 
         // Add voting power for operated staking pools.
         for (uint256 i = 0; i != operatedPoolIds.length; i++) {
             for (uint256 j = 0; j != i; j++) {
-                require(
+                require(operatedPoolIds[i] != operatedPoolIds[j], "getVotingPower/DUPLICATE_POOL_ID");
-                    operatedPoolIds[i] != operatedPoolIds[j],
-                    "getVotingPower/DUPLICATE_POOL_ID"
-                );
             }
             IStaking.Pool memory pool = stakingProxy.getStakingPool(operatedPoolIds[i]);
-            require(
+            require(pool.operator == account, "getVotingPower/POOL_NOT_OPERATED_BY_ACCOUNT");
-                pool.operator == account,
-                "getVotingPower/POOL_NOT_OPERATED_BY_ACCOUNT"
-            );
             uint96 stakeDelegatedToPool = stakingProxy
                 .getTotalStakeDelegatedToPool(operatedPoolIds[i])
                 .currentEpochBalance;
@@ -322,25 +260,10 @@ contract ZrxTreasury is
     /// @dev Checks whether the given proposal is executable.
     ///      Reverts if not.
     /// @param proposal The proposal to check.
-    function _assertProposalExecutable(
+    function _assertProposalExecutable(Proposal memory proposal, ProposedAction[] memory actions) private view {
-        Proposal memory proposal,
+        require(keccak256(abi.encode(actions)) == proposal.actionsHash, "_assertProposalExecutable/INVALID_ACTIONS");
-        ProposedAction[] memory actions
+        require(_hasProposalPassed(proposal), "_assertProposalExecutable/PROPOSAL_HAS_NOT_PASSED");
-    )
+        require(!proposal.executed, "_assertProposalExecutable/PROPOSAL_ALREADY_EXECUTED");
-        private
-        view
-    {
-        require(
-            keccak256(abi.encode(actions)) == proposal.actionsHash,
-            "_assertProposalExecutable/INVALID_ACTIONS"
-        );
-        require(
-            _hasProposalPassed(proposal),
-            "_assertProposalExecutable/PROPOSAL_HAS_NOT_PASSED"
-        );
-        require(
-            !proposal.executed,
-            "_assertProposalExecutable/PROPOSAL_ALREADY_EXECUTED"
-        );
         require(
             stakingProxy.currentEpoch() == proposal.executionEpoch,
             "_assertProposalExecutable/CANNOT_EXECUTE_THIS_EPOCH"
@@ -350,11 +273,7 @@ contract ZrxTreasury is
     /// @dev Checks whether the given proposal has passed or not.
     /// @param proposal The proposal to check.
     /// @return hasPassed Whether the proposal has passed.
-    function _hasProposalPassed(Proposal memory proposal)
+    function _hasProposalPassed(Proposal memory proposal) private view returns (bool hasPassed) {
-        private
-        view
-        returns (bool hasPassed)
-    {
         // Proposal is not passed until the vote is over.
         if (!_hasVoteEnded(proposal.voteEpoch)) {
             return false;
@@ -374,11 +293,7 @@ contract ZrxTreasury is
     ///      epoch has ended or not.
     /// @param voteEpoch The epoch at which the vote started.
     /// @return hasEnded Whether the vote has ended.
-    function _hasVoteEnded(uint256 voteEpoch)
+    function _hasVoteEnded(uint256 voteEpoch) private view returns (bool hasEnded) {
-        private
-        view
-        returns (bool hasEnded)
-    {
         uint256 currentEpoch = stakingProxy.currentEpoch();
         if (currentEpoch < voteEpoch) {
             return false;
@@ -388,9 +303,7 @@ contract ZrxTreasury is
         }
         // voteEpoch == currentEpoch
         // Vote ends at currentEpochStartTime + votingPeriod
-        uint256 voteEndTime = stakingProxy
+        uint256 voteEndTime = stakingProxy.currentEpochStartTimeInSeconds().safeAdd(votingPeriod);
-            .currentEpochStartTimeInSeconds()
-            .safeAdd(votingPeriod);
         return block.timestamp > voteEndTime;
     }
 
@@ -402,9 +315,7 @@ contract ZrxTreasury is
         uint256 proposalId,
         bool support,
         bytes32[] memory operatedPoolIds
-    )
+    ) private {
-        private
-    {
         if (proposalId >= proposalCount()) {
             revert("_castVote/INVALID_PROPOSAL_ID");
         }
@@ -413,10 +324,7 @@ contract ZrxTreasury is
         }
 
         Proposal memory proposal = proposals[proposalId];
-        if (
+        if (proposal.voteEpoch != stakingProxy.currentEpoch() || _hasVoteEnded(proposal.voteEpoch)) {
-            proposal.voteEpoch != stakingProxy.currentEpoch() ||
-            _hasVoteEnded(proposal.voteEpoch)
-        ) {
             revert("_castVote/VOTING_IS_CLOSED");
         }
 
@@ -426,27 +334,21 @@ contract ZrxTreasury is
         }
 
         if (support) {
-            proposals[proposalId].votesFor = proposals[proposalId].votesFor
+            proposals[proposalId].votesFor = proposals[proposalId].votesFor.safeAdd(votingPower);
-                .safeAdd(votingPower);
         } else {
-            proposals[proposalId].votesAgainst = proposals[proposalId].votesAgainst
+            proposals[proposalId].votesAgainst = proposals[proposalId].votesAgainst.safeAdd(votingPower);
-                .safeAdd(votingPower);
         }
         hasVoted[proposalId][voter] = true;
 
-        emit VoteCast(
+        emit VoteCast(voter, operatedPoolIds, proposalId, support, votingPower);
-            voter,
-            operatedPoolIds,
-            proposalId,
-            support,
-            votingPower
-        );
     }
 
     /// @dev Gets the Ethereum chain id
     function _getChainId() private pure returns (uint256) {
         uint256 chainId;
-        assembly { chainId := chainid() }
+        assembly {
+            chainId := chainid()
+        }
         return chainId;
     }
 }

contracts/utils/contracts/src/Authorizable.sol

@@ -23,14 +23,10 @@ import "./LibAuthorizableRichErrors.sol";
 import "./LibRichErrors.sol";
 import "./Ownable.sol";
 
-
 // solhint-disable no-empty-blocks
-contract Authorizable is
+contract Authorizable is Ownable, IAuthorizable {
-    Ownable,
-    IAuthorizable
-{
     /// @dev Only authorized addresses can invoke functions with this modifier.
-    modifier onlyAuthorized {
+    modifier onlyAuthorized() {
         _assertSenderIsAuthorized();
         _;
     }
@@ -38,33 +34,24 @@ contract Authorizable is
     /// @dev Whether an adderss is authorized to call privileged functions.
     /// @param 0 Address to query.
     /// @return 0 Whether the address is authorized.
-    mapping (address => bool) public authorized;
+    mapping(address => bool) public authorized;
     /// @dev Whether an adderss is authorized to call privileged functions.
     /// @param 0 Index of authorized address.
     /// @return 0 Authorized address.
     address[] public authorities;
 
     /// @dev Initializes the `owner` address.
-    constructor()
+    constructor() public Ownable() {}
-        public
-        Ownable()
-    {}
 
     /// @dev Authorizes an address.
     /// @param target Address to authorize.
-    function addAuthorizedAddress(address target)
+    function addAuthorizedAddress(address target) external onlyOwner {
-        external
-        onlyOwner
-    {
         _addAuthorizedAddress(target);
     }
 
     /// @dev Removes authorizion of an address.
     /// @param target Address to remove authorization from.
-    function removeAuthorizedAddress(address target)
+    function removeAuthorizedAddress(address target) external onlyOwner {
-        external
-        onlyOwner
-    {
         if (!authorized[target]) {
             LibRichErrors.rrevert(LibAuthorizableRichErrors.TargetNotAuthorizedError(target));
         }
@@ -79,31 +66,18 @@ contract Authorizable is
     /// @dev Removes authorizion of an address.
     /// @param target Address to remove authorization from.
     /// @param index Index of target in authorities array.
-    function removeAuthorizedAddressAtIndex(
+    function removeAuthorizedAddressAtIndex(address target, uint256 index) external onlyOwner {
-        address target,
-        uint256 index
-    )
-        external
-        onlyOwner
-    {
         _removeAuthorizedAddressAtIndex(target, index);
     }
 
     /// @dev Gets all authorized addresses.
     /// @return Array of authorized addresses.
-    function getAuthorizedAddresses()
+    function getAuthorizedAddresses() external view returns (address[] memory) {
-        external
-        view
-        returns (address[] memory)
-    {
         return authorities;
     }
 
     /// @dev Reverts if msg.sender is not authorized.
-    function _assertSenderIsAuthorized()
+    function _assertSenderIsAuthorized() internal view {
-        internal
-        view
-    {
         if (!authorized[msg.sender]) {
             LibRichErrors.rrevert(LibAuthorizableRichErrors.SenderNotAuthorizedError(msg.sender));
         }
@@ -111,9 +85,7 @@ contract Authorizable is
 
     /// @dev Authorizes an address.
     /// @param target Address to authorize.
-    function _addAuthorizedAddress(address target)
+    function _addAuthorizedAddress(address target) internal {
-        internal
-    {
         // Ensure that the target is not the zero address.
         if (target == address(0)) {
             LibRichErrors.rrevert(LibAuthorizableRichErrors.ZeroCantBeAuthorizedError());
@@ -132,26 +104,15 @@ contract Authorizable is
     /// @dev Removes authorizion of an address.
     /// @param target Address to remove authorization from.
     /// @param index Index of target in authorities array.
-    function _removeAuthorizedAddressAtIndex(
+    function _removeAuthorizedAddressAtIndex(address target, uint256 index) internal {
-        address target,
-        uint256 index
-    )
-        internal
-    {
         if (!authorized[target]) {
             LibRichErrors.rrevert(LibAuthorizableRichErrors.TargetNotAuthorizedError(target));
         }
         if (index >= authorities.length) {
-            LibRichErrors.rrevert(LibAuthorizableRichErrors.IndexOutOfBoundsError(
+            LibRichErrors.rrevert(LibAuthorizableRichErrors.IndexOutOfBoundsError(index, authorities.length));
-                index,
-                authorities.length
-            ));
         }
         if (authorities[index] != target) {
-            LibRichErrors.rrevert(LibAuthorizableRichErrors.AuthorizedAddressMismatchError(
+            LibRichErrors.rrevert(LibAuthorizableRichErrors.AuthorizedAddressMismatchError(authorities[index], target));
-                authorities[index],
-                target
-            ));
         }
 
         delete authorized[target];

contracts/utils/contracts/src/D18.sol

@@ -18,201 +18,124 @@
 
 pragma solidity ^0.5.16;
 
-
 /// @dev A library for working with 18 digit, base 10 decimals.
 library D18 {
-
     /// @dev Decimal places for dydx value quantities.
     uint256 private constant PRECISION = 18;
     /// @dev 1.0 in base-18 decimal.
-    int256 private constant DECIMAL_ONE = int256(10 ** PRECISION);
+    int256 private constant DECIMAL_ONE = int256(10**PRECISION);
     /// @dev Minimum signed integer value.
-    int256 private constant MIN_INT256_VALUE = int256(0x8000000000000000000000000000000000000000000000000000000000000000);
+    int256 private constant MIN_INT256_VALUE =
+        int256(0x8000000000000000000000000000000000000000000000000000000000000000);
 
     /// @dev Return `1.0`
-    function one()
+    function one() internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         r = DECIMAL_ONE;
     }
 
     /// @dev Add two decimals.
-    function add(int256 a, int256 b)
+    function add(int256 a, int256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         r = _add(a, b);
     }
 
     /// @dev Add two decimals.
-    function add(uint256 a, int256 b)
+    function add(uint256 a, int256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         r = _add(int256(a), b);
     }
 
     /// @dev Add two decimals.
-    function add(int256 a, uint256 b)
+    function add(int256 a, uint256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         r = _add(a, int256(b));
     }
 
     /// @dev Add two decimals.
-    function add(uint256 a, uint256 b)
+    function add(uint256 a, uint256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         r = _add(int256(a), int256(b));
     }
 
     /// @dev Subract two decimals.
-    function sub(int256 a, int256 b)
+    function sub(int256 a, int256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         r = _add(a, -b);
     }
 
     /// @dev Subract two decimals.
-    function sub(uint256 a, int256 b)
+    function sub(uint256 a, int256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         r = _add(int256(a), -b);
     }
 
     /// @dev Subract two decimals.
-    function sub(uint256 a, uint256 b)
+    function sub(uint256 a, uint256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         r = _add(int256(a), -int256(b));
     }
 
     /// @dev Multiply two decimals.
-    function mul(int256 a, int256 b)
+    function mul(int256 a, int256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         r = _div(_mul(a, b), DECIMAL_ONE);
     }
 
     /// @dev Multiply two decimals.
-    function mul(uint256 a, int256 b)
+    function mul(uint256 a, int256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         r = _div(_mul(int256(a), b), DECIMAL_ONE);
     }
 
     /// @dev Multiply two decimals.
-    function mul(int256 a, uint256 b)
+    function mul(int256 a, uint256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         r = _div(_mul(a, int256(b)), DECIMAL_ONE);
     }
 
     /// @dev Multiply two decimals.
-    function mul(uint256 a, uint256 b)
+    function mul(uint256 a, uint256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         r = _div(_mul(int256(a), int256(b)), DECIMAL_ONE);
     }
 
     /// @dev Divide two decimals.
-    function div(int256 a, int256 b)
+    function div(int256 a, int256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         r = _div(_mul(a, DECIMAL_ONE), b);
     }
 
     /// @dev Divide two decimals.
-    function div(uint256 a, int256 b)
+    function div(uint256 a, int256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         r = _div(_mul(int256(a), DECIMAL_ONE), b);
     }
 
     /// @dev Divide two decimals.
-    function div(int256 a, uint256 b)
+    function div(int256 a, uint256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         r = _div(_mul(a, DECIMAL_ONE), int256(b));
     }
 
     /// @dev Divide two decimals.
-    function div(uint256 a, uint256 b)
+    function div(uint256 a, uint256 b) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         r = _div(_mul(int256(a), DECIMAL_ONE), int256(b));
     }
 
     /// @dev Safely convert an unsigned integer into a signed integer.
-    function toSigned(uint256 a)
+    function toSigned(uint256 a) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG");
         r = int256(a);
     }
 
     /// @dev Clip a signed value to be positive.
-    function clip(int256 a)
+    function clip(int256 a) internal pure returns (int256 r) {
-        internal
-        pure
-        returns (int256 r)
-    {
         r = a < 0 ? 0 : a;
     }
 
     /// @dev Safely multiply two signed integers.
-    function _mul(int256 a, int256 b)
+    function _mul(int256 a, int256 b) private pure returns (int256 r) {
-        private
-        pure
-        returns (int256 r)
-    {
         if (a == 0 || b == 0) {
             return 0;
         }
@@ -222,27 +145,15 @@ library D18 {
     }
 
     /// @dev Safely divide two signed integers.
-    function _div(int256 a, int256 b)
+    function _div(int256 a, int256 b) private pure returns (int256 r) {
-        private
-        pure
-        returns (int256 r)
-    {
         require(b != 0, "D18/DECIMAL_DIV_BY_ZERO");
         require(a != MIN_INT256_VALUE || b != -1, "D18/DECIMAL_DIV_OVERFLOW");
         r = a / b;
     }
 
     /// @dev Safely add two signed integers.
-    function _add(int256 a, int256 b)
+    function _add(int256 a, int256 b) private pure returns (int256 r) {
-        private
-        pure
-        returns (int256 r)
-    {
         r = a + b;
-        require(
+        require(!((a < 0 && b < 0 && r > a) || (a > 0 && b > 0 && r < a)), "D18/DECIMAL_ADD_OVERFLOW");
-            !((a < 0 && b < 0 && r > a) || (a > 0 && b > 0 && r < a)),
-            "D18/DECIMAL_ADD_OVERFLOW"
-        );
     }
-
 }

contracts/utils/contracts/src/DeploymentConstants.sol

@@ -18,48 +18,46 @@
 
 pragma solidity ^0.5.9;
 
-
 contract DeploymentConstants {
-
     // solhint-disable separate-by-one-line-in-contract
 
     // Mainnet addresses ///////////////////////////////////////////////////////
     /// @dev Mainnet address of the WETH contract.
-    address constant private WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+    address private constant WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
     /// @dev Mainnet address of the KyberNetworkProxy contract.
-    address constant private KYBER_NETWORK_PROXY_ADDRESS = 0x9AAb3f75489902f3a48495025729a0AF77d4b11e;
+    address private constant KYBER_NETWORK_PROXY_ADDRESS = 0x9AAb3f75489902f3a48495025729a0AF77d4b11e;
     /// @dev Mainnet address of the KyberHintHandler contract.
-    address constant private KYBER_HINT_HANDLER_ADDRESS = 0xa1C0Fa73c39CFBcC11ec9Eb1Afc665aba9996E2C;
+    address private constant KYBER_HINT_HANDLER_ADDRESS = 0xa1C0Fa73c39CFBcC11ec9Eb1Afc665aba9996E2C;
     /// @dev Mainnet address of the `UniswapExchangeFactory` contract.
-    address constant private UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95;
+    address private constant UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95;
     /// @dev Mainnet address of the `UniswapV2Router01` contract.
-    address constant private UNISWAP_V2_ROUTER_01_ADDRESS = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a;
+    address private constant UNISWAP_V2_ROUTER_01_ADDRESS = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a;
     /// @dev Mainnet address of the Eth2Dai `MatchingMarket` contract.
-    address constant private ETH2DAI_ADDRESS = 0x794e6e91555438aFc3ccF1c5076A74F42133d08D;
+    address private constant ETH2DAI_ADDRESS = 0x794e6e91555438aFc3ccF1c5076A74F42133d08D;
     /// @dev Mainnet address of the `ERC20BridgeProxy` contract
-    address constant private ERC20_BRIDGE_PROXY_ADDRESS = 0x8ED95d1746bf1E4dAb58d8ED4724f1Ef95B20Db0;
+    address private constant ERC20_BRIDGE_PROXY_ADDRESS = 0x8ED95d1746bf1E4dAb58d8ED4724f1Ef95B20Db0;
     ///@dev Mainnet address of the `Dai` (multi-collateral) contract
-    address constant private DAI_ADDRESS = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
+    address private constant DAI_ADDRESS = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
     /// @dev Mainnet address of the `Chai` contract
-    address constant private CHAI_ADDRESS = 0x06AF07097C9Eeb7fD685c692751D5C66dB49c215;
+    address private constant CHAI_ADDRESS = 0x06AF07097C9Eeb7fD685c692751D5C66dB49c215;
     /// @dev Mainnet address of the 0x DevUtils contract.
-    address constant private DEV_UTILS_ADDRESS = 0x74134CF88b21383713E096a5ecF59e297dc7f547;
+    address private constant DEV_UTILS_ADDRESS = 0x74134CF88b21383713E096a5ecF59e297dc7f547;
     /// @dev Kyber ETH pseudo-address.
-    address constant internal KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+    address internal constant KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
     /// @dev Mainnet address of the dYdX contract.
-    address constant private DYDX_ADDRESS = 0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e;
+    address private constant DYDX_ADDRESS = 0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e;
     /// @dev Mainnet address of the GST2 contract
-    address constant private GST_ADDRESS = 0x0000000000b3F879cb30FE243b4Dfee438691c04;
+    address private constant GST_ADDRESS = 0x0000000000b3F879cb30FE243b4Dfee438691c04;
     /// @dev Mainnet address of the GST Collector
-    address constant private GST_COLLECTOR_ADDRESS = 0x000000D3b08566BE75A6DB803C03C85C0c1c5B96;
+    address private constant GST_COLLECTOR_ADDRESS = 0x000000D3b08566BE75A6DB803C03C85C0c1c5B96;
     /// @dev Mainnet address of the mStable mUSD contract.
-    address constant private MUSD_ADDRESS = 0xe2f2a5C287993345a840Db3B0845fbC70f5935a5;
+    address private constant MUSD_ADDRESS = 0xe2f2a5C287993345a840Db3B0845fbC70f5935a5;
     /// @dev Mainnet address of the Mooniswap Registry contract
-    address constant private MOONISWAP_REGISTRY = 0x71CD6666064C3A1354a3B4dca5fA1E2D3ee7D303;
+    address private constant MOONISWAP_REGISTRY = 0x71CD6666064C3A1354a3B4dca5fA1E2D3ee7D303;
     /// @dev Mainnet address of the DODO Registry (ZOO) contract
-    address constant private DODO_REGISTRY = 0x3A97247DF274a17C59A3bd12735ea3FcDFb49950;
+    address private constant DODO_REGISTRY = 0x3A97247DF274a17C59A3bd12735ea3FcDFb49950;
     /// @dev Mainnet address of the DODO Helper contract
-    address constant private DODO_HELPER = 0x533dA777aeDCE766CEAe696bf90f8541A4bA80Eb;
+    address private constant DODO_HELPER = 0x533dA777aeDCE766CEAe696bf90f8541A4bA80Eb;
 
     // // Ropsten addresses ///////////////////////////////////////////////////////
     // /// @dev Mainnet address of the WETH contract.
@@ -153,171 +151,103 @@ contract DeploymentConstants {
 
     /// @dev Overridable way to get the `KyberNetworkProxy` address.
     /// @return kyberAddress The `IKyberNetworkProxy` address.
-    function _getKyberNetworkProxyAddress()
+    function _getKyberNetworkProxyAddress() internal view returns (address kyberAddress) {
-        internal
-        view
-        returns (address kyberAddress)
-    {
         return KYBER_NETWORK_PROXY_ADDRESS;
     }
 
     /// @dev Overridable way to get the `KyberHintHandler` address.
     /// @return kyberAddress The `IKyberHintHandler` address.
-    function _getKyberHintHandlerAddress()
+    function _getKyberHintHandlerAddress() internal view returns (address hintHandlerAddress) {
-        internal
-        view
-        returns (address hintHandlerAddress)
-    {
         return KYBER_HINT_HANDLER_ADDRESS;
     }
 
     /// @dev Overridable way to get the WETH address.
     /// @return wethAddress The WETH address.
-    function _getWethAddress()
+    function _getWethAddress() internal view returns (address wethAddress) {
-        internal
-        view
-        returns (address wethAddress)
-    {
         return WETH_ADDRESS;
     }
 
     /// @dev Overridable way to get the `UniswapExchangeFactory` address.
     /// @return uniswapAddress The `UniswapExchangeFactory` address.
-    function _getUniswapExchangeFactoryAddress()
+    function _getUniswapExchangeFactoryAddress() internal view returns (address uniswapAddress) {
-        internal
-        view
-        returns (address uniswapAddress)
-    {
         return UNISWAP_EXCHANGE_FACTORY_ADDRESS;
     }
 
     /// @dev Overridable way to get the `UniswapV2Router01` address.
     /// @return uniswapRouterAddress The `UniswapV2Router01` address.
-    function _getUniswapV2Router01Address()
+    function _getUniswapV2Router01Address() internal view returns (address uniswapRouterAddress) {
-        internal
-        view
-        returns (address uniswapRouterAddress)
-    {
         return UNISWAP_V2_ROUTER_01_ADDRESS;
     }
 
     /// @dev An overridable way to retrieve the Eth2Dai `MatchingMarket` contract.
     /// @return eth2daiAddress The Eth2Dai `MatchingMarket` contract.
-    function _getEth2DaiAddress()
+    function _getEth2DaiAddress() internal view returns (address eth2daiAddress) {
-        internal
-        view
-        returns (address eth2daiAddress)
-    {
         return ETH2DAI_ADDRESS;
     }
 
     /// @dev An overridable way to retrieve the `ERC20BridgeProxy` contract.
     /// @return erc20BridgeProxyAddress The `ERC20BridgeProxy` contract.
-    function _getERC20BridgeProxyAddress()
+    function _getERC20BridgeProxyAddress() internal view returns (address erc20BridgeProxyAddress) {
-        internal
-        view
-        returns (address erc20BridgeProxyAddress)
-    {
         return ERC20_BRIDGE_PROXY_ADDRESS;
     }
 
     /// @dev An overridable way to retrieve the `Dai` contract.
     /// @return daiAddress The `Dai` contract.
-    function _getDaiAddress()
+    function _getDaiAddress() internal view returns (address daiAddress) {
-        internal
-        view
-        returns (address daiAddress)
-    {
         return DAI_ADDRESS;
     }
 
     /// @dev An overridable way to retrieve the `Chai` contract.
     /// @return chaiAddress The `Chai` contract.
-    function _getChaiAddress()
+    function _getChaiAddress() internal view returns (address chaiAddress) {
-        internal
-        view
-        returns (address chaiAddress)
-    {
         return CHAI_ADDRESS;
     }
 
     /// @dev An overridable way to retrieve the 0x `DevUtils` contract address.
     /// @return devUtils The 0x `DevUtils` contract address.
-    function _getDevUtilsAddress()
+    function _getDevUtilsAddress() internal view returns (address devUtils) {
-        internal
-        view
-        returns (address devUtils)
-    {
         return DEV_UTILS_ADDRESS;
     }
 
     /// @dev Overridable way to get the DyDx contract.
     /// @return exchange The DyDx exchange contract.
-    function _getDydxAddress()
+    function _getDydxAddress() internal view returns (address dydxAddress) {
-        internal
-        view
-        returns (address dydxAddress)
-    {
         return DYDX_ADDRESS;
     }
 
     /// @dev An overridable way to retrieve the GST2 contract address.
     /// @return gst The GST contract.
-    function _getGstAddress()
+    function _getGstAddress() internal view returns (address gst) {
-        internal
-        view
-        returns (address gst)
-    {
         return GST_ADDRESS;
     }
 
     /// @dev An overridable way to retrieve the GST Collector address.
     /// @return collector The GST collector address.
-    function _getGstCollectorAddress()
+    function _getGstCollectorAddress() internal view returns (address collector) {
-        internal
-        view
-        returns (address collector)
-    {
         return GST_COLLECTOR_ADDRESS;
     }
 
     /// @dev An overridable way to retrieve the mStable mUSD address.
     /// @return musd The mStable mUSD address.
-    function _getMUsdAddress()
+    function _getMUsdAddress() internal view returns (address musd) {
-        internal
-        view
-        returns (address musd)
-    {
         return MUSD_ADDRESS;
     }
 
     /// @dev An overridable way to retrieve the Mooniswap registry address.
     /// @return registry The Mooniswap registry address.
-    function _getMooniswapAddress()
+    function _getMooniswapAddress() internal view returns (address) {
-        internal
-        view
-        returns (address)
-    {
         return MOONISWAP_REGISTRY;
     }
 
     /// @dev An overridable way to retrieve the DODO Registry contract address.
     /// @return registry The DODO Registry contract address.
-    function _getDODORegistryAddress()
+    function _getDODORegistryAddress() internal view returns (address) {
-        internal
-        view
-        returns (address)
-    {
         return DODO_REGISTRY;
     }
 
     /// @dev An overridable way to retrieve the DODO Helper contract address.
     /// @return registry The DODO Helper contract address.
-    function _getDODOHelperAddress()
+    function _getDODOHelperAddress() internal view returns (address) {
-        internal
-        view
-        returns (address)
-    {
         return DODO_HELPER;
     }
 }

contracts/utils/contracts/src/LibAddress.sol

@@ -18,12 +18,10 @@
 
 pragma solidity ^0.5.9;
 
-
 /**
  * Utility library of inline functions on addresses
  */
 library LibAddress {
-
     /**
      * Returns whether the target address is a contract
      * @dev This function will return false if invoked during the constructor of a contract,
@@ -40,8 +38,9 @@ library LibAddress {
         // 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) }
+        assembly {
+            size := extcodesize(account)
+        }
         return size > 0;
     }
-
 }

contracts/utils/contracts/src/LibAddressArray.sol

@@ -22,9 +22,7 @@ import "./LibAddressArrayRichErrors.sol";
 import "./LibBytes.sol";
 import "./LibRichErrors.sol";
 
-
 library LibAddressArray {
-
     /// @dev Append a new address to an array of addresses.
     ///      The `addressArray` may need to be reallocated to make space
     ///      for the new address. Because of this we return the resulting
@@ -32,11 +30,7 @@ library LibAddressArray {
     /// @param addressArray Array of addresses.
     /// @param addressToAppend  Address to append.
     /// @return Array of addresses: [... addressArray, addressToAppend]
-    function append(address[] memory addressArray, address addressToAppend)
+    function append(address[] memory addressArray, address addressToAppend) internal pure returns (address[] memory) {
-        internal
-        pure
-        returns (address[] memory)
-    {
         // Get stats on address array and free memory
         uint256 freeMemPtr = 0;
         uint256 addressArrayBeginPtr = 0;
@@ -54,10 +48,7 @@ library LibAddressArray {
         //  `freeMemPtr` > `addressArrayEndPtr`: Some value occupies memory after `addressArray`
         //  `freeMemPtr` < `addressArrayEndPtr`: Memory has not been managed properly.
         if (freeMemPtr < addressArrayEndPtr) {
-            LibRichErrors.rrevert(LibAddressArrayRichErrors.MismanagedMemoryError(
+            LibRichErrors.rrevert(LibAddressArrayRichErrors.MismanagedMemoryError(freeMemPtr, addressArrayEndPtr));
-                freeMemPtr,
-                addressArrayEndPtr
-            ));
         }
 
         // If free memory begins at the end of `addressArray`
@@ -92,13 +83,8 @@ library LibAddressArray {
     /// @param addressArray Array of addresses.
     /// @param target Address to search for in array.
     /// @return True if the addressArray contains the target.
-    function contains(address[] memory addressArray, address target)
+    function contains(address[] memory addressArray, address target) internal pure returns (bool success) {
-        internal
-        pure
-        returns (bool success)
-    {
         assembly {
-
             // Calculate byte length of array
             let arrayByteLen := mul(mload(addressArray), 32)
             // Calculate beginning of array contents
@@ -107,8 +93,11 @@ library LibAddressArray {
             let arrayContentsEnd := add(arrayContentsStart, arrayByteLen)
 
             // Loop through array
-            for {let i:= arrayContentsStart} lt(i, arrayContentsEnd) {i := add(i, 32)} {
+            for {
-
+                let i := arrayContentsStart
+            } lt(i, arrayContentsEnd) {
+                i := add(i, 32)
+            } {
                 // Load array element
                 let arrayElement := mload(i)
 
@@ -134,7 +123,6 @@ library LibAddressArray {
         returns (bool success, uint256 index)
     {
         assembly {
-
             // Calculate byte length of array
             let arrayByteLen := mul(mload(addressArray), 32)
             // Calculate beginning of array contents
@@ -143,8 +131,11 @@ library LibAddressArray {
             let arrayContentsEnd := add(arrayContentsStart, arrayByteLen)
 
             // Loop through array
-            for {let i:= arrayContentsStart} lt(i, arrayContentsEnd) {i := add(i, 32)} {
+            for {
-
+                let i := arrayContentsStart
+            } lt(i, arrayContentsEnd) {
+                i := add(i, 32)
+            } {
                 // Load array element
                 let arrayElement := mload(i)
 

contracts/utils/contracts/src/LibAddressArrayRichErrors.sol

@@ -18,26 +18,16 @@
 
 pragma solidity ^0.5.9;
 
-
 library LibAddressArrayRichErrors {
-
     // bytes4(keccak256("MismanagedMemoryError(uint256,uint256)"))
-    bytes4 internal constant MISMANAGED_MEMORY_ERROR_SELECTOR =
+    bytes4 internal constant MISMANAGED_MEMORY_ERROR_SELECTOR = 0x5fc83722;
-        0x5fc83722;
 
     // solhint-disable func-name-mixedcase
-    function MismanagedMemoryError(
+    function MismanagedMemoryError(uint256 freeMemPtr, uint256 addressArrayEndPtr)
-        uint256 freeMemPtr,
-        uint256 addressArrayEndPtr
-    )
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encodeWithSelector(
+        return abi.encodeWithSelector(MISMANAGED_MEMORY_ERROR_SELECTOR, freeMemPtr, addressArrayEndPtr);
-            MISMANAGED_MEMORY_ERROR_SELECTOR,
-            freeMemPtr,
-            addressArrayEndPtr
-        );
     }
 }

contracts/utils/contracts/src/LibAuthorizableRichErrors.sol

@@ -18,102 +18,47 @@
 
 pragma solidity ^0.5.9;
 
-
 library LibAuthorizableRichErrors {
-
     // bytes4(keccak256("AuthorizedAddressMismatchError(address,address)"))
-    bytes4 internal constant AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR =
+    bytes4 internal constant AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR = 0x140a84db;
-        0x140a84db;
 
     // bytes4(keccak256("IndexOutOfBoundsError(uint256,uint256)"))
-    bytes4 internal constant INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR =
+    bytes4 internal constant INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR = 0xe9f83771;
-        0xe9f83771;
 
     // bytes4(keccak256("SenderNotAuthorizedError(address)"))
-    bytes4 internal constant SENDER_NOT_AUTHORIZED_ERROR_SELECTOR =
+    bytes4 internal constant SENDER_NOT_AUTHORIZED_ERROR_SELECTOR = 0xb65a25b9;
-        0xb65a25b9;
 
     // bytes4(keccak256("TargetAlreadyAuthorizedError(address)"))
-    bytes4 internal constant TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR =
+    bytes4 internal constant TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR = 0xde16f1a0;
-        0xde16f1a0;
 
     // bytes4(keccak256("TargetNotAuthorizedError(address)"))
-    bytes4 internal constant TARGET_NOT_AUTHORIZED_ERROR_SELECTOR =
+    bytes4 internal constant TARGET_NOT_AUTHORIZED_ERROR_SELECTOR = 0xeb5108a2;
-        0xeb5108a2;
 
     // bytes4(keccak256("ZeroCantBeAuthorizedError()"))
-    bytes internal constant ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES =
+    bytes internal constant ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES = hex"57654fe4";
-        hex"57654fe4";
 
     // solhint-disable func-name-mixedcase
-    function AuthorizedAddressMismatchError(
+    function AuthorizedAddressMismatchError(address authorized, address target) internal pure returns (bytes memory) {
-        address authorized,
+        return abi.encodeWithSelector(AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR, authorized, target);
-        address target
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR,
-            authorized,
-            target
-        );
     }
 
-    function IndexOutOfBoundsError(
+    function IndexOutOfBoundsError(uint256 index, uint256 length) internal pure returns (bytes memory) {
-        uint256 index,
+        return abi.encodeWithSelector(INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR, index, length);
-        uint256 length
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR,
-            index,
-            length
-        );
     }
 
-    function SenderNotAuthorizedError(address sender)
+    function SenderNotAuthorizedError(address sender) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(SENDER_NOT_AUTHORIZED_ERROR_SELECTOR, sender);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            SENDER_NOT_AUTHORIZED_ERROR_SELECTOR,
-            sender
-        );
     }
 
-    function TargetAlreadyAuthorizedError(address target)
+    function TargetAlreadyAuthorizedError(address target) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR, target);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR,
-            target
-        );
     }
 
-    function TargetNotAuthorizedError(address target)
+    function TargetNotAuthorizedError(address target) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(TARGET_NOT_AUTHORIZED_ERROR_SELECTOR, target);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            TARGET_NOT_AUTHORIZED_ERROR_SELECTOR,
-            target
-        );
     }
 
-    function ZeroCantBeAuthorizedError()
+    function ZeroCantBeAuthorizedError() internal pure returns (bytes memory) {
-        internal
-        pure
-        returns (bytes memory)
-    {
         return ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES;
     }
 }

contracts/utils/contracts/src/LibBytes.sol

@@ -21,9 +21,7 @@ pragma solidity ^0.5.9;
 import "./LibBytesRichErrors.sol";
 import "./LibRichErrors.sol";
 
-
 library LibBytes {
-
     using LibBytes for bytes;
 
     /// @dev Gets the memory address for a byte array.
@@ -31,11 +29,7 @@ library LibBytes {
     /// @return memoryAddress Memory address of byte array. This
     ///         points to the header of the byte array which contains
     ///         the length.
-    function rawAddress(bytes memory input)
+    function rawAddress(bytes memory input) internal pure returns (uint256 memoryAddress) {
-        internal
-        pure
-        returns (uint256 memoryAddress)
-    {
         assembly {
             memoryAddress := input
         }
@@ -45,11 +39,7 @@ library LibBytes {
     /// @dev Gets the memory address for the contents of a byte array.
     /// @param input Byte array to lookup.
     /// @return memoryAddress Memory address of the contents of the byte array.
-    function contentAddress(bytes memory input)
+    function contentAddress(bytes memory input) internal pure returns (uint256 memoryAddress) {
-        internal
-        pure
-        returns (uint256 memoryAddress)
-    {
         assembly {
             memoryAddress := add(input, 32)
         }
@@ -64,10 +54,7 @@ library LibBytes {
         uint256 dest,
         uint256 source,
         uint256 length
-    )
+    ) internal pure {
-        internal
-        pure
-    {
         if (length < 32) {
             // Handle a partial word by reading destination and masking
             // off the bits we are interested in.
@@ -119,7 +106,11 @@ library LibBytes {
                     // Note: the first check is always true,
                     // this could have been a do-while loop.
                     // solhint-disable-next-line no-empty-blocks
-                    for {} lt(source, sEnd) {} {
+                    for {
+
+                    } lt(source, sEnd) {
+
+                    } {
                         mstore(dest, mload(source))
                         source := add(source, 32)
                         dest := add(dest, 32)
@@ -150,7 +141,11 @@ library LibBytes {
                     // Note: the first check is always true,
                     // this could have been a do-while loop.
                     // solhint-disable-next-line no-empty-blocks
-                    for {} slt(dest, dEnd) {} {
+                    for {
+
+                    } slt(dest, dEnd) {
+
+                    } {
                         mstore(dEnd, mload(sEnd))
                         sEnd := sub(sEnd, 32)
                         dEnd := sub(dEnd, 32)
@@ -172,35 +167,31 @@ library LibBytes {
         bytes memory b,
         uint256 from,
         uint256 to
-    )
+    ) internal pure returns (bytes memory result) {
-        internal
-        pure
-        returns (bytes memory result)
-    {
         // Ensure that the from and to positions are valid positions for a slice within
         // the byte array that is being used.
         if (from > to) {
-            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
+            LibRichErrors.rrevert(
-                LibBytesRichErrors.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
+                LibBytesRichErrors.InvalidByteOperationError(
-                from,
+                    LibBytesRichErrors.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
-                to
+                    from,
-            ));
+                    to
+                )
+            );
         }
         if (to > b.length) {
-            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
+            LibRichErrors.rrevert(
-                LibBytesRichErrors.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
+                LibBytesRichErrors.InvalidByteOperationError(
-                to,
+                    LibBytesRichErrors.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
-                b.length
+                    to,
-            ));
+                    b.length
+                )
+            );
         }
 
         // Create a new bytes structure and copy contents
         result = new bytes(to - from);
-        memCopy(
+        memCopy(result.contentAddress(), b.contentAddress() + from, result.length);
-            result.contentAddress(),
-            b.contentAddress() + from,
-            result.length
-        );
         return result;
     }
 
@@ -214,26 +205,26 @@ library LibBytes {
         bytes memory b,
         uint256 from,
         uint256 to
-    )
+    ) internal pure returns (bytes memory result) {
-        internal
-        pure
-        returns (bytes memory result)
-    {
         // Ensure that the from and to positions are valid positions for a slice within
         // the byte array that is being used.
         if (from > to) {
-            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
+            LibRichErrors.rrevert(
-                LibBytesRichErrors.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
+                LibBytesRichErrors.InvalidByteOperationError(
-                from,
+                    LibBytesRichErrors.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
-                to
+                    from,
-            ));
+                    to
+                )
+            );
         }
         if (to > b.length) {
-            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
+            LibRichErrors.rrevert(
-                LibBytesRichErrors.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
+                LibBytesRichErrors.InvalidByteOperationError(
-                to,
+                    LibBytesRichErrors.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
-                b.length
+                    to,
-            ));
+                    b.length
+                )
+            );
         }
 
         // Create a new bytes structure around [from, to) in-place.
@@ -247,17 +238,15 @@ library LibBytes {
     /// @dev Pops the last byte off of a byte array by modifying its length.
     /// @param b Byte array that will be modified.
     /// @return The byte that was popped off.
-    function popLastByte(bytes memory b)
+    function popLastByte(bytes memory b) internal pure returns (bytes1 result) {
-        internal
-        pure
-        returns (bytes1 result)
-    {
         if (b.length == 0) {
-            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
+            LibRichErrors.rrevert(
-                LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,
+                LibBytesRichErrors.InvalidByteOperationError(
-                b.length,
+                    LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,
-                0
+                    b.length,
-            ));
+                    0
+                )
+            );
         }
 
         // Store last byte.
@@ -275,14 +264,7 @@ library LibBytes {
     /// @param lhs First byte array to compare.
     /// @param rhs Second byte array to compare.
     /// @return True if arrays are the same. False otherwise.
-    function equals(
+    function equals(bytes memory lhs, bytes memory rhs) internal pure returns (bool equal) {
-        bytes memory lhs,
-        bytes memory rhs
-    )
-        internal
-        pure
-        returns (bool equal)
-    {
         // Keccak gas cost is 30 + numWords * 6. This is a cheap way to compare.
         // We early exit on unequal lengths, but keccak would also correctly
         // handle this.
@@ -293,20 +275,15 @@ library LibBytes {
     /// @param b Byte array containing an address.
     /// @param index Index in byte array of address.
     /// @return address from byte array.
-    function readAddress(
+    function readAddress(bytes memory b, uint256 index) internal pure returns (address result) {
-        bytes memory b,
-        uint256 index
-    )
-        internal
-        pure
-        returns (address result)
-    {
         if (b.length < index + 20) {
-            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
+            LibRichErrors.rrevert(
-                LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
+                LibBytesRichErrors.InvalidByteOperationError(
-                b.length,
+                    LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
-                index + 20 // 20 is length of address
+                    b.length,
-            ));
+                    index + 20 // 20 is length of address
+                )
+            );
         }
 
         // Add offset to index:
@@ -332,16 +309,15 @@ library LibBytes {
         bytes memory b,
         uint256 index,
         address input
-    )
+    ) internal pure {
-        internal
-        pure
-    {
         if (b.length < index + 20) {
-            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
+            LibRichErrors.rrevert(
-                LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
+                LibBytesRichErrors.InvalidByteOperationError(
-                b.length,
+                    LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
-                index + 20 // 20 is length of address
+                    b.length,
-            ));
+                    index + 20 // 20 is length of address
+                )
+            );
         }
 
         // Add offset to index:
@@ -377,20 +353,15 @@ library LibBytes {
     /// @param b Byte array containing a bytes32 value.
     /// @param index Index in byte array of bytes32 value.
     /// @return bytes32 value from byte array.
-    function readBytes32(
+    function readBytes32(bytes memory b, uint256 index) internal pure returns (bytes32 result) {
-        bytes memory b,
-        uint256 index
-    )
-        internal
-        pure
-        returns (bytes32 result)
-    {
         if (b.length < index + 32) {
-            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
+            LibRichErrors.rrevert(
-                LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
+                LibBytesRichErrors.InvalidByteOperationError(
-                b.length,
+                    LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
-                index + 32
+                    b.length,
-            ));
+                    index + 32
+                )
+            );
         }
 
         // Arrays are prefixed by a 256 bit length parameter
@@ -411,16 +382,15 @@ library LibBytes {
         bytes memory b,
         uint256 index,
         bytes32 input
-    )
+    ) internal pure {
-        internal
-        pure
-    {
         if (b.length < index + 32) {
-            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
+            LibRichErrors.rrevert(
-                LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
+                LibBytesRichErrors.InvalidByteOperationError(
-                b.length,
+                    LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
-                index + 32
+                    b.length,
-            ));
+                    index + 32
+                )
+            );
         }
 
         // Arrays are prefixed by a 256 bit length parameter
@@ -436,14 +406,7 @@ library LibBytes {
     /// @param b Byte array containing a uint256 value.
     /// @param index Index in byte array of uint256 value.
     /// @return uint256 value from byte array.
-    function readUint256(
+    function readUint256(bytes memory b, uint256 index) internal pure returns (uint256 result) {
-        bytes memory b,
-        uint256 index
-    )
-        internal
-        pure
-        returns (uint256 result)
-    {
         result = uint256(readBytes32(b, index));
         return result;
     }
@@ -456,10 +419,7 @@ library LibBytes {
         bytes memory b,
         uint256 index,
         uint256 input
-    )
+    ) internal pure {
-        internal
-        pure
-    {
         writeBytes32(b, index, bytes32(input));
     }
 
@@ -467,20 +427,15 @@ library LibBytes {
     /// @param b Byte array containing a bytes4 value.
     /// @param index Index in byte array of bytes4 value.
     /// @return bytes4 value from byte array.
-    function readBytes4(
+    function readBytes4(bytes memory b, uint256 index) internal pure returns (bytes4 result) {
-        bytes memory b,
-        uint256 index
-    )
-        internal
-        pure
-        returns (bytes4 result)
-    {
         if (b.length < index + 4) {
-            LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
+            LibRichErrors.rrevert(
-                LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,
+                LibBytesRichErrors.InvalidByteOperationError(
-                b.length,
+                    LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,
-                index + 4
+                    b.length,
-            ));
+                    index + 4
+                )
+            );
         }
 
         // Arrays are prefixed by a 32 byte length field
@@ -501,10 +456,7 @@ library LibBytes {
     ///      Increasing length may lead to appending adjacent in-memory bytes to the end of the byte array.
     /// @param b Bytes array to write new length to.
     /// @param length New length of byte array.
-    function writeLength(bytes memory b, uint256 length)
+    function writeLength(bytes memory b, uint256 length) internal pure {
-        internal
-        pure
-    {
         assembly {
             mstore(b, length)
         }

contracts/utils/contracts/src/LibBytesRichErrors.sol

@@ -18,9 +18,7 @@
 
 pragma solidity ^0.5.9;
 
-
 library LibBytesRichErrors {
-
     enum InvalidByteOperationErrorCodes {
         FromLessThanOrEqualsToRequired,
         ToLessThanOrEqualsLengthRequired,
@@ -33,24 +31,14 @@ library LibBytesRichErrors {
     }
 
     // bytes4(keccak256("InvalidByteOperationError(uint8,uint256,uint256)"))
-    bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR =
+    bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR = 0x28006595;
-        0x28006595;
 
     // solhint-disable func-name-mixedcase
     function InvalidByteOperationError(
         InvalidByteOperationErrorCodes errorCode,
         uint256 offset,
         uint256 required
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(INVALID_BYTE_OPERATION_ERROR_SELECTOR, errorCode, offset, required);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            INVALID_BYTE_OPERATION_ERROR_SELECTOR,
-            errorCode,
-            offset,
-            required
-        );
     }
 }

contracts/utils/contracts/src/LibEIP1271.sol

@@ -18,10 +18,8 @@
 
 pragma solidity ^0.5.9;
 
-
 contract LibEIP1271 {
-
     /// @dev Magic bytes returned by EIP1271 wallets on success.
     /// @return 0 Magic bytes.
-    bytes4 constant public EIP1271_MAGIC_VALUE = 0x20c13b0b;
+    bytes4 public constant EIP1271_MAGIC_VALUE = 0x20c13b0b;
 }

contracts/utils/contracts/src/LibEIP712.sol

@@ -18,9 +18,7 @@
 
 pragma solidity ^0.5.9;
 
-
 library LibEIP712 {
-
     // Hash of the EIP712 Domain Separator Schema
     // keccak256(abi.encodePacked(
     //     "EIP712Domain(",
@@ -30,7 +28,8 @@ library LibEIP712 {
     //     "address verifyingContract",
     //     ")"
     // ))
-    bytes32 constant internal _EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
+    bytes32 internal constant _EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH =
+        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
 
     /// @dev Calculates a EIP712 domain separator.
     /// @param name The EIP712 domain name.
@@ -42,11 +41,7 @@ library LibEIP712 {
         string memory version,
         uint256 chainId,
         address verifyingContract
-    )
+    ) internal pure returns (bytes32 result) {
-        internal
-        pure
-        returns (bytes32 result)
-    {
         bytes32 schemaHash = _EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH;
 
         // Assembly for more efficient computing:
@@ -84,11 +79,7 @@ library LibEIP712 {
     ///                         with getDomainHash().
     /// @param hashStruct The EIP712 hash struct.
     /// @return EIP712 hash applied to the given EIP712 Domain.
-    function hashEIP712Message(bytes32 eip712DomainHash, bytes32 hashStruct)
+    function hashEIP712Message(bytes32 eip712DomainHash, bytes32 hashStruct) internal pure returns (bytes32 result) {
-        internal
-        pure
-        returns (bytes32 result)
-    {
         // Assembly for more efficient computing:
         // keccak256(abi.encodePacked(
         //     EIP191_HEADER,
@@ -100,9 +91,9 @@ library LibEIP712 {
             // Load free memory pointer
             let memPtr := mload(64)
 
-            mstore(memPtr, 0x1901000000000000000000000000000000000000000000000000000000000000)  // EIP191 header
+            mstore(memPtr, 0x1901000000000000000000000000000000000000000000000000000000000000) // EIP191 header
-            mstore(add(memPtr, 2), eip712DomainHash)                                            // EIP712 domain hash
+            mstore(add(memPtr, 2), eip712DomainHash) // EIP712 domain hash
-            mstore(add(memPtr, 34), hashStruct)                                                 // Hash of struct
+            mstore(add(memPtr, 34), hashStruct) // Hash of struct
 
             // Compute hash
             result := keccak256(memPtr, 66)

contracts/utils/contracts/src/LibFractions.sol

@@ -2,9 +2,7 @@ pragma solidity ^0.5.9;
 
 import "./LibSafeMath.sol";
 
-
 library LibFractions {
-
     using LibSafeMath for uint256;
 
     /// @dev Safely adds two fractions `n1/d1 + n2/d2`
@@ -19,23 +17,14 @@ library LibFractions {
         uint256 d1,
         uint256 n2,
         uint256 d2
-    )
+    ) internal pure returns (uint256 numerator, uint256 denominator) {
-        internal
-        pure
-        returns (
-            uint256 numerator,
-            uint256 denominator
-        )
-    {
         if (n1 == 0) {
             return (numerator = n2, denominator = d2);
         }
         if (n2 == 0) {
             return (numerator = n1, denominator = d1);
         }
-        numerator = n1
+        numerator = n1.safeMul(d2).safeAdd(n2.safeMul(d1));
-            .safeMul(d2)
-            .safeAdd(n2.safeMul(d1));
         denominator = d1.safeMul(d2);
         return (numerator, denominator);
     }
@@ -52,14 +41,7 @@ library LibFractions {
         uint256 numerator,
         uint256 denominator,
         uint256 maxValue
-    )
+    ) internal pure returns (uint256 scaledNumerator, uint256 scaledDenominator) {
-        internal
-        pure
-        returns (
-            uint256 scaledNumerator,
-            uint256 scaledDenominator
-        )
-    {
         // If either the numerator or the denominator are > `maxValue`,
         // re-scale them by `maxValue` to prevent overflows in future operations.
         if (numerator > maxValue || denominator > maxValue) {
@@ -80,18 +62,12 @@ library LibFractions {
     /// @param denominator The denominator.
     /// @return scaledNumerator The rescaled numerator.
     /// @return scaledDenominator The rescaled denominator.
-    function normalize(
+    function normalize(uint256 numerator, uint256 denominator)
-        uint256 numerator,
-        uint256 denominator
-    )
         internal
         pure
-        returns (
+        returns (uint256 scaledNumerator, uint256 scaledDenominator)
-            uint256 scaledNumerator,
-            uint256 scaledDenominator
-        )
     {
-        return normalize(numerator, denominator, 2 ** 127);
+        return normalize(numerator, denominator, 2**127);
     }
 
     /// @dev Safely scales the difference between two fractions.
@@ -107,25 +83,15 @@ library LibFractions {
         uint256 n2,
         uint256 d2,
         uint256 s
-    )
+    ) internal pure returns (uint256 result) {
-        internal
-        pure
-        returns (uint256 result)
-    {
         if (s == 0) {
             return 0;
         }
         if (n2 == 0) {
-            return result = s
+            return result = s.safeMul(n1).safeDiv(d1);
-                .safeMul(n1)
-                .safeDiv(d1);
         }
-        uint256 numerator = n1
+        uint256 numerator = n1.safeMul(d2).safeSub(n2.safeMul(d1));
-            .safeMul(d2)
-            .safeSub(n2.safeMul(d1));
         uint256 tmp = numerator.safeDiv(d2);
-        return s
+        return s.safeMul(tmp).safeDiv(d1);
-            .safeMul(tmp)
-            .safeDiv(d1);
     }
 }

contracts/utils/contracts/src/LibMath.sol

@@ -22,9 +22,7 @@ import "./LibSafeMath.sol";
 import "./LibRichErrors.sol";
 import "./LibMathRichErrors.sol";
 
-
 library LibMath {
-
     using LibSafeMath for uint256;
 
     /// @dev Calculates partial value given a numerator and denominator rounded down.
@@ -37,21 +35,9 @@ library LibMath {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (uint256 partialAmount) {
-        internal
+        if (isRoundingErrorFloor(numerator, denominator, target)) {
-        pure
+            LibRichErrors.rrevert(LibMathRichErrors.RoundingError(numerator, denominator, target));
-        returns (uint256 partialAmount)
-    {
-        if (isRoundingErrorFloor(
-                numerator,
-                denominator,
-                target
-        )) {
-            LibRichErrors.rrevert(LibMathRichErrors.RoundingError(
-                numerator,
-                denominator,
-                target
-            ));
         }
 
         partialAmount = numerator.safeMul(target).safeDiv(denominator);
@@ -68,29 +54,15 @@ library LibMath {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (uint256 partialAmount) {
-        internal
+        if (isRoundingErrorCeil(numerator, denominator, target)) {
-        pure
+            LibRichErrors.rrevert(LibMathRichErrors.RoundingError(numerator, denominator, target));
-        returns (uint256 partialAmount)
-    {
-        if (isRoundingErrorCeil(
-                numerator,
-                denominator,
-                target
-        )) {
-            LibRichErrors.rrevert(LibMathRichErrors.RoundingError(
-                numerator,
-                denominator,
-                target
-            ));
         }
 
         // safeDiv computes `floor(a / b)`. We use the identity (a, b integer):
         //       ceil(a / b) = floor((a + b - 1) / b)
         // To implement `ceil(a / b)` using safeDiv.
-        partialAmount = numerator.safeMul(target)
+        partialAmount = numerator.safeMul(target).safeAdd(denominator.safeSub(1)).safeDiv(denominator);
-            .safeAdd(denominator.safeSub(1))
-            .safeDiv(denominator);
 
         return partialAmount;
     }
@@ -104,11 +76,7 @@ library LibMath {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (uint256 partialAmount) {
-        internal
-        pure
-        returns (uint256 partialAmount)
-    {
         partialAmount = numerator.safeMul(target).safeDiv(denominator);
         return partialAmount;
     }
@@ -122,17 +90,11 @@ library LibMath {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (uint256 partialAmount) {
-        internal
-        pure
-        returns (uint256 partialAmount)
-    {
         // safeDiv computes `floor(a / b)`. We use the identity (a, b integer):
         //       ceil(a / b) = floor((a + b - 1) / b)
         // To implement `ceil(a / b)` using safeDiv.
-        partialAmount = numerator.safeMul(target)
+        partialAmount = numerator.safeMul(target).safeAdd(denominator.safeSub(1)).safeDiv(denominator);
-            .safeAdd(denominator.safeSub(1))
-            .safeDiv(denominator);
 
         return partialAmount;
     }
@@ -146,11 +108,7 @@ library LibMath {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (bool isError) {
-        internal
-        pure
-        returns (bool isError)
-    {
         if (denominator == 0) {
             LibRichErrors.rrevert(LibMathRichErrors.DivisionByZeroError());
         }
@@ -181,11 +139,7 @@ library LibMath {
         //        1000 * remainder  <  numerator * target
         // so we have a rounding error iff:
         //        1000 * remainder  >=  numerator * target
-        uint256 remainder = mulmod(
+        uint256 remainder = mulmod(target, numerator, denominator);
-            target,
-            numerator,
-            denominator
-        );
         isError = remainder.safeMul(1000) >= numerator.safeMul(target);
         return isError;
     }
@@ -199,11 +153,7 @@ library LibMath {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (bool isError) {
-        internal
-        pure
-        returns (bool isError)
-    {
         if (denominator == 0) {
             LibRichErrors.rrevert(LibMathRichErrors.DivisionByZeroError());
         }
@@ -216,11 +166,7 @@ library LibMath {
             return false;
         }
         // Compute remainder as before
-        uint256 remainder = mulmod(
+        uint256 remainder = mulmod(target, numerator, denominator);
-            target,
-            numerator,
-            denominator
-        );
         remainder = denominator.safeSub(remainder) % denominator;
         isError = remainder.safeMul(1000) >= numerator.safeMul(target);
         return isError;

contracts/utils/contracts/src/LibMathRichErrors.sol

@@ -1,22 +1,14 @@
 pragma solidity ^0.5.9;
 
-
 library LibMathRichErrors {
-
     // bytes4(keccak256("DivisionByZeroError()"))
-    bytes internal constant DIVISION_BY_ZERO_ERROR =
+    bytes internal constant DIVISION_BY_ZERO_ERROR = hex"a791837c";
-        hex"a791837c";
 
     // bytes4(keccak256("RoundingError(uint256,uint256,uint256)"))
-    bytes4 internal constant ROUNDING_ERROR_SELECTOR =
+    bytes4 internal constant ROUNDING_ERROR_SELECTOR = 0x339f3de2;
-        0x339f3de2;
 
     // solhint-disable func-name-mixedcase
-    function DivisionByZeroError()
+    function DivisionByZeroError() internal pure returns (bytes memory) {
-        internal
-        pure
-        returns (bytes memory)
-    {
         return DIVISION_BY_ZERO_ERROR;
     }
 
@@ -24,16 +16,7 @@ library LibMathRichErrors {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(ROUNDING_ERROR_SELECTOR, numerator, denominator, target);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            ROUNDING_ERROR_SELECTOR,
-            numerator,
-            denominator,
-            target
-        );
     }
 }

contracts/utils/contracts/src/LibOwnableRichErrors.sol

@@ -1,37 +1,18 @@
 pragma solidity ^0.5.9;
 
-
 library LibOwnableRichErrors {
-
     // bytes4(keccak256("OnlyOwnerError(address,address)"))
-    bytes4 internal constant ONLY_OWNER_ERROR_SELECTOR =
+    bytes4 internal constant ONLY_OWNER_ERROR_SELECTOR = 0x1de45ad1;
-        0x1de45ad1;
 
     // bytes4(keccak256("TransferOwnerToZeroError()"))
-    bytes internal constant TRANSFER_OWNER_TO_ZERO_ERROR_BYTES =
+    bytes internal constant TRANSFER_OWNER_TO_ZERO_ERROR_BYTES = hex"e69edc3e";
-        hex"e69edc3e";
 
     // solhint-disable func-name-mixedcase
-    function OnlyOwnerError(
+    function OnlyOwnerError(address sender, address owner) internal pure returns (bytes memory) {
-        address sender,
+        return abi.encodeWithSelector(ONLY_OWNER_ERROR_SELECTOR, sender, owner);
-        address owner
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            ONLY_OWNER_ERROR_SELECTOR,
-            sender,
-            owner
-        );
     }
 
-    function TransferOwnerToZeroError()
+    function TransferOwnerToZeroError() internal pure returns (bytes memory) {
-        internal
-        pure
-        returns (bytes memory)
-    {
         return TRANSFER_OWNER_TO_ZERO_ERROR_BYTES;
     }
 }

contracts/utils/contracts/src/LibReentrancyGuardRichErrors.sol

@@ -18,19 +18,12 @@
 
 pragma solidity ^0.5.9;
 
-
 library LibReentrancyGuardRichErrors {
-
     // bytes4(keccak256("IllegalReentrancyError()"))
-    bytes internal constant ILLEGAL_REENTRANCY_ERROR_SELECTOR_BYTES =
+    bytes internal constant ILLEGAL_REENTRANCY_ERROR_SELECTOR_BYTES = hex"0c3b823f";
-        hex"0c3b823f";
 
     // solhint-disable func-name-mixedcase
-    function IllegalReentrancyError()
+    function IllegalReentrancyError() internal pure returns (bytes memory) {
-        internal
-        pure
-        returns (bytes memory)
-    {
         return ILLEGAL_REENTRANCY_ERROR_SELECTOR_BYTES;
     }
 }

contracts/utils/contracts/src/LibRichErrors.sol

@@ -18,12 +18,9 @@
 
 pragma solidity ^0.5.9;
 
-
 library LibRichErrors {
-
     // bytes4(keccak256("Error(string)"))
-    bytes4 internal constant STANDARD_ERROR_SELECTOR =
+    bytes4 internal constant STANDARD_ERROR_SELECTOR = 0x08c379a0;
-        0x08c379a0;
 
     // solhint-disable func-name-mixedcase
     /// @dev ABI encode a standard, string revert error payload.
@@ -31,26 +28,15 @@ library LibRichErrors {
     ///      solidity statement. It has the function signature `Error(string)`.
     /// @param message The error string.
     /// @return The ABI encoded error.
-    function StandardError(
+    function StandardError(string memory message) internal pure returns (bytes memory) {
-        string memory message
+        return abi.encodeWithSelector(STANDARD_ERROR_SELECTOR, bytes(message));
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            STANDARD_ERROR_SELECTOR,
-            bytes(message)
-        );
     }
+
     // solhint-enable func-name-mixedcase
 
     /// @dev Reverts an encoded rich revert reason `errorData`.
     /// @param errorData ABI encoded error data.
-    function rrevert(bytes memory errorData)
+    function rrevert(bytes memory errorData) internal pure {
-        internal
-        pure
-    {
         assembly {
             revert(add(errorData, 0x20), mload(errorData))
         }

contracts/utils/contracts/src/LibSafeMath.sol

@@ -3,88 +3,62 @@ pragma solidity ^0.5.9;
 import "./LibRichErrors.sol";
 import "./LibSafeMathRichErrors.sol";
 
-
 library LibSafeMath {
-
+    function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
-    function safeMul(uint256 a, uint256 b)
-        internal
-        pure
-        returns (uint256)
-    {
         if (a == 0) {
             return 0;
         }
         uint256 c = a * b;
         if (c / a != b) {
-            LibRichErrors.rrevert(LibSafeMathRichErrors.Uint256BinOpError(
+            LibRichErrors.rrevert(
-                LibSafeMathRichErrors.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,
+                LibSafeMathRichErrors.Uint256BinOpError(
-                a,
+                    LibSafeMathRichErrors.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,
-                b
+                    a,
-            ));
+                    b
+                )
+            );
         }
         return c;
     }
 
-    function safeDiv(uint256 a, uint256 b)
+    function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
-        internal
-        pure
-        returns (uint256)
-    {
         if (b == 0) {
-            LibRichErrors.rrevert(LibSafeMathRichErrors.Uint256BinOpError(
+            LibRichErrors.rrevert(
-                LibSafeMathRichErrors.BinOpErrorCodes.DIVISION_BY_ZERO,
+                LibSafeMathRichErrors.Uint256BinOpError(LibSafeMathRichErrors.BinOpErrorCodes.DIVISION_BY_ZERO, a, b)
-                a,
+            );
-                b
-            ));
         }
         uint256 c = a / b;
         return c;
     }
 
-    function safeSub(uint256 a, uint256 b)
+    function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
-        internal
-        pure
-        returns (uint256)
-    {
         if (b > a) {
-            LibRichErrors.rrevert(LibSafeMathRichErrors.Uint256BinOpError(
+            LibRichErrors.rrevert(
-                LibSafeMathRichErrors.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,
+                LibSafeMathRichErrors.Uint256BinOpError(
-                a,
+                    LibSafeMathRichErrors.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,
-                b
+                    a,
-            ));
+                    b
+                )
+            );
         }
         return a - b;
     }
 
-    function safeAdd(uint256 a, uint256 b)
+    function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
-        internal
-        pure
-        returns (uint256)
-    {
         uint256 c = a + b;
         if (c < a) {
-            LibRichErrors.rrevert(LibSafeMathRichErrors.Uint256BinOpError(
+            LibRichErrors.rrevert(
-                LibSafeMathRichErrors.BinOpErrorCodes.ADDITION_OVERFLOW,
+                LibSafeMathRichErrors.Uint256BinOpError(LibSafeMathRichErrors.BinOpErrorCodes.ADDITION_OVERFLOW, a, b)
-                a,
+            );
-                b
-            ));
         }
         return c;
     }
 
-    function max256(uint256 a, uint256 b)
+    function max256(uint256 a, uint256 b) internal pure returns (uint256) {
-        internal
-        pure
-        returns (uint256)
-    {
         return a >= b ? a : b;
     }
 
-    function min256(uint256 a, uint256 b)
+    function min256(uint256 a, uint256 b) internal pure returns (uint256) {
-        internal
-        pure
-        returns (uint256)
-    {
         return a < b ? a : b;
     }
 }

contracts/utils/contracts/src/LibSafeMathRichErrors.sol

@@ -1,15 +1,11 @@
 pragma solidity ^0.5.9;
 
-
 library LibSafeMathRichErrors {
-
     // bytes4(keccak256("Uint256BinOpError(uint8,uint256,uint256)"))
-    bytes4 internal constant UINT256_BINOP_ERROR_SELECTOR =
+    bytes4 internal constant UINT256_BINOP_ERROR_SELECTOR = 0xe946c1bb;
-        0xe946c1bb;
 
     // bytes4(keccak256("Uint256DowncastError(uint8,uint256)"))
-    bytes4 internal constant UINT256_DOWNCAST_ERROR_SELECTOR =
+    bytes4 internal constant UINT256_DOWNCAST_ERROR_SELECTOR = 0xc996af7b;
-        0xc996af7b;
 
     enum BinOpErrorCodes {
         ADDITION_OVERFLOW,
@@ -29,31 +25,11 @@ library LibSafeMathRichErrors {
         BinOpErrorCodes errorCode,
         uint256 a,
         uint256 b
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(UINT256_BINOP_ERROR_SELECTOR, errorCode, a, b);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            UINT256_BINOP_ERROR_SELECTOR,
-            errorCode,
-            a,
-            b
-        );
     }
 
-    function Uint256DowncastError(
+    function Uint256DowncastError(DowncastErrorCodes errorCode, uint256 a) internal pure returns (bytes memory) {
-        DowncastErrorCodes errorCode,
+        return abi.encodeWithSelector(UINT256_DOWNCAST_ERROR_SELECTOR, errorCode, a);
-        uint256 a
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            UINT256_DOWNCAST_ERROR_SELECTOR,
-            errorCode,
-            a
-        );
     }
 }

contracts/utils/contracts/src/Ownable.sol

@@ -22,17 +22,12 @@ import "./interfaces/IOwnable.sol";
 import "./LibOwnableRichErrors.sol";
 import "./LibRichErrors.sol";
 
-
+contract Ownable is IOwnable {
-contract Ownable is
-    IOwnable
-{
     /// @dev The owner of this contract.
     /// @return 0 The owner address.
     address public owner;
 
-    constructor ()
+    constructor() public {
-        public
-    {
         owner = msg.sender;
     }
 
@@ -43,10 +38,7 @@ contract Ownable is
 
     /// @dev Change the owner of this contract.
     /// @param newOwner New owner address.
-    function transferOwnership(address newOwner)
+    function transferOwnership(address newOwner) public onlyOwner {
-        public
-        onlyOwner
-    {
         if (newOwner == address(0)) {
             LibRichErrors.rrevert(LibOwnableRichErrors.TransferOwnerToZeroError());
         } else {
@@ -55,15 +47,9 @@ contract Ownable is
         }
     }
 
-    function _assertSenderIsOwner()
+    function _assertSenderIsOwner() internal view {
-        internal
-        view
-    {
         if (msg.sender != owner) {
-            LibRichErrors.rrevert(LibOwnableRichErrors.OnlyOwnerError(
+            LibRichErrors.rrevert(LibOwnableRichErrors.OnlyOwnerError(msg.sender, owner));
-                msg.sender,
-                owner
-            ));
         }
     }
 }

contracts/utils/contracts/src/ReentrancyGuard.sol

@@ -21,9 +21,7 @@ pragma solidity ^0.5.9;
 import "./LibReentrancyGuardRichErrors.sol";
 import "./LibRichErrors.sol";
 
-
 contract ReentrancyGuard {
-
     // Locked state of mutex.
     bool private _locked = false;
 
@@ -35,22 +33,16 @@ contract ReentrancyGuard {
         _unlockMutex();
     }
 
-    function _lockMutexOrThrowIfAlreadyLocked()
+    function _lockMutexOrThrowIfAlreadyLocked() internal {
-        internal
-    {
         // Ensure mutex is unlocked.
         if (_locked) {
-            LibRichErrors.rrevert(
+            LibRichErrors.rrevert(LibReentrancyGuardRichErrors.IllegalReentrancyError());
-                LibReentrancyGuardRichErrors.IllegalReentrancyError()
-            );
         }
         // Lock mutex.
         _locked = true;
     }
 
-    function _unlockMutex()
+    function _unlockMutex() internal {
-        internal
-    {
         // Unlock mutex.
         _locked = false;
     }

contracts/utils/contracts/src/Refundable.sol

@@ -20,27 +20,23 @@ pragma solidity ^0.5.9;
 
 import "./ReentrancyGuard.sol";
 
-
+contract Refundable is ReentrancyGuard {
-contract Refundable is
-    ReentrancyGuard
-{
-
     // This bool is used by the refund modifier to allow for lazily evaluated refunds.
     bool internal _shouldNotRefund;
 
-    modifier refundFinalBalance {
+    modifier refundFinalBalance() {
         _;
         _refundNonZeroBalanceIfEnabled();
     }
 
-    modifier refundFinalBalanceNoReentry {
+    modifier refundFinalBalanceNoReentry() {
         _lockMutexOrThrowIfAlreadyLocked();
         _;
         _refundNonZeroBalanceIfEnabled();
         _unlockMutex();
     }
 
-    modifier disableRefundUntilEnd {
+    modifier disableRefundUntilEnd() {
         if (_areRefundsDisabled()) {
             _;
         } else {
@@ -50,41 +46,29 @@ contract Refundable is
         }
     }
 
-    function _refundNonZeroBalanceIfEnabled()
+    function _refundNonZeroBalanceIfEnabled() internal {
-        internal
-    {
         if (!_areRefundsDisabled()) {
             _refundNonZeroBalance();
         }
     }
 
-    function _refundNonZeroBalance()
+    function _refundNonZeroBalance() internal {
-        internal
-    {
         uint256 balance = address(this).balance;
         if (balance > 0) {
             msg.sender.transfer(balance);
         }
     }
 
-    function _disableRefund()
+    function _disableRefund() internal {
-        internal
-    {
         _shouldNotRefund = true;
     }
 
-    function _enableAndRefundNonZeroBalance()
+    function _enableAndRefundNonZeroBalance() internal {
-        internal
-    {
         _shouldNotRefund = false;
         _refundNonZeroBalance();
     }
 
-    function _areRefundsDisabled()
+    function _areRefundsDisabled() internal view returns (bool) {
-        internal
-        view
-        returns (bool)
-    {
         return _shouldNotRefund;
     }
 }

contracts/utils/contracts/src/interfaces/IAuthorizable.sol

@@ -20,45 +20,27 @@ pragma solidity ^0.5.9;
 
 import "./IOwnable.sol";
 
-
+contract IAuthorizable is IOwnable {
-contract IAuthorizable is
-    IOwnable
-{
     // Event logged when a new address is authorized.
-    event AuthorizedAddressAdded(
+    event AuthorizedAddressAdded(address indexed target, address indexed caller);
-        address indexed target,
-        address indexed caller
-    );
 
     // Event logged when a currently authorized address is unauthorized.
-    event AuthorizedAddressRemoved(
+    event AuthorizedAddressRemoved(address indexed target, address indexed caller);
-        address indexed target,
-        address indexed caller
-    );
 
     /// @dev Authorizes an address.
     /// @param target Address to authorize.
-    function addAuthorizedAddress(address target)
+    function addAuthorizedAddress(address target) external;
-        external;
 
     /// @dev Removes authorizion of an address.
     /// @param target Address to remove authorization from.
-    function removeAuthorizedAddress(address target)
+    function removeAuthorizedAddress(address target) external;
-        external;
 
     /// @dev Removes authorizion of an address.
     /// @param target Address to remove authorization from.
     /// @param index Index of target in authorities array.
-    function removeAuthorizedAddressAtIndex(
+    function removeAuthorizedAddressAtIndex(address target, uint256 index) external;
-        address target,
-        uint256 index
-    )
-        external;
 
     /// @dev Gets all authorized addresses.
     /// @return Array of authorized addresses.
-    function getAuthorizedAddresses()
+    function getAuthorizedAddresses() external view returns (address[] memory);
-        external
-        view
-        returns (address[] memory);
 }

contracts/utils/contracts/src/interfaces/IOwnable.sol

@@ -18,9 +18,7 @@
 
 pragma solidity ^0.5.9;
 
-
 contract IOwnable {
-
     /// @dev Emitted by Ownable when ownership is transferred.
     /// @param previousOwner The previous owner of the contract.
     /// @param newOwner The new owner of the contract.
@@ -28,6 +26,5 @@ contract IOwnable {
 
     /// @dev Transfers ownership of the contract to a new address.
     /// @param newOwner The address that will become the owner.
-    function transferOwnership(address newOwner)
+    function transferOwnership(address newOwner) public;
-        public;
 }

contracts/utils/contracts/src/v06/AuthorizableV06.sol

@@ -24,14 +24,10 @@ import "./errors/LibRichErrorsV06.sol";
 import "./errors/LibAuthorizableRichErrorsV06.sol";
 import "./OwnableV06.sol";
 
-
 // solhint-disable no-empty-blocks
-contract AuthorizableV06 is
+contract AuthorizableV06 is OwnableV06, IAuthorizableV06 {
-    OwnableV06,
-    IAuthorizableV06
-{
     /// @dev Only authorized addresses can invoke functions with this modifier.
-    modifier onlyAuthorized {
+    modifier onlyAuthorized() {
         _assertSenderIsAuthorized();
         _;
     }
@@ -39,35 +35,24 @@ contract AuthorizableV06 is
     // @dev Whether an address is authorized to call privileged functions.
     // @param 0 Address to query.
     // @return 0 Whether the address is authorized.
-    mapping (address => bool) public override authorized;
+    mapping(address => bool) public override authorized;
     // @dev Whether an address is authorized to call privileged functions.
     // @param 0 Index of authorized address.
     // @return 0 Authorized address.
     address[] public override authorities;
 
     /// @dev Initializes the `owner` address.
-    constructor()
+    constructor() public OwnableV06() {}
-        public
-        OwnableV06()
-    {}
 
     /// @dev Authorizes an address.
     /// @param target Address to authorize.
-    function addAuthorizedAddress(address target)
+    function addAuthorizedAddress(address target) external override onlyOwner {
-        external
-        override
-        onlyOwner
-    {
         _addAuthorizedAddress(target);
     }
 
     /// @dev Removes authorizion of an address.
     /// @param target Address to remove authorization from.
-    function removeAuthorizedAddress(address target)
+    function removeAuthorizedAddress(address target) external override onlyOwner {
-        external
-        override
-        onlyOwner
-    {
         if (!authorized[target]) {
             LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.TargetNotAuthorizedError(target));
         }
@@ -82,33 +67,18 @@ contract AuthorizableV06 is
     /// @dev Removes authorizion of an address.
     /// @param target Address to remove authorization from.
     /// @param index Index of target in authorities array.
-    function removeAuthorizedAddressAtIndex(
+    function removeAuthorizedAddressAtIndex(address target, uint256 index) external override onlyOwner {
-        address target,
-        uint256 index
-    )
-        external
-        override
-        onlyOwner
-    {
         _removeAuthorizedAddressAtIndex(target, index);
     }
 
     /// @dev Gets all authorized addresses.
     /// @return Array of authorized addresses.
-    function getAuthorizedAddresses()
+    function getAuthorizedAddresses() external view override returns (address[] memory) {
-        external
-        override
-        view
-        returns (address[] memory)
-    {
         return authorities;
     }
 
     /// @dev Reverts if msg.sender is not authorized.
-    function _assertSenderIsAuthorized()
+    function _assertSenderIsAuthorized() internal view {
-        internal
-        view
-    {
         if (!authorized[msg.sender]) {
             LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.SenderNotAuthorizedError(msg.sender));
         }
@@ -116,9 +86,7 @@ contract AuthorizableV06 is
 
     /// @dev Authorizes an address.
     /// @param target Address to authorize.
-    function _addAuthorizedAddress(address target)
+    function _addAuthorizedAddress(address target) internal {
-        internal
-    {
         // Ensure that the target is not the zero address.
         if (target == address(0)) {
             LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.ZeroCantBeAuthorizedError());
@@ -137,26 +105,17 @@ contract AuthorizableV06 is
     /// @dev Removes authorizion of an address.
     /// @param target Address to remove authorization from.
     /// @param index Index of target in authorities array.
-    function _removeAuthorizedAddressAtIndex(
+    function _removeAuthorizedAddressAtIndex(address target, uint256 index) internal {
-        address target,
-        uint256 index
-    )
-        internal
-    {
         if (!authorized[target]) {
             LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.TargetNotAuthorizedError(target));
         }
         if (index >= authorities.length) {
-            LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.IndexOutOfBoundsError(
+            LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.IndexOutOfBoundsError(index, authorities.length));
-                index,
-                authorities.length
-            ));
         }
         if (authorities[index] != target) {
-            LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.AuthorizedAddressMismatchError(
+            LibRichErrorsV06.rrevert(
-                authorities[index],
+                LibAuthorizableRichErrorsV06.AuthorizedAddressMismatchError(authorities[index], target)
-                target
+            );
-            ));
         }
 
         delete authorized[target];

contracts/utils/contracts/src/v06/LibBytesV06.sol

@@ -22,9 +22,7 @@ pragma solidity ^0.6.5;
 import "./errors/LibBytesRichErrorsV06.sol";
 import "./errors/LibRichErrorsV06.sol";
 
-
 library LibBytesV06 {
-
     using LibBytesV06 for bytes;
 
     /// @dev Gets the memory address for a byte array.
@@ -32,11 +30,7 @@ library LibBytesV06 {
     /// @return memoryAddress Memory address of byte array. This
     ///         points to the header of the byte array which contains
     ///         the length.
-    function rawAddress(bytes memory input)
+    function rawAddress(bytes memory input) internal pure returns (uint256 memoryAddress) {
-        internal
-        pure
-        returns (uint256 memoryAddress)
-    {
         assembly {
             memoryAddress := input
         }
@@ -46,11 +40,7 @@ library LibBytesV06 {
     /// @dev Gets the memory address for the contents of a byte array.
     /// @param input Byte array to lookup.
     /// @return memoryAddress Memory address of the contents of the byte array.
-    function contentAddress(bytes memory input)
+    function contentAddress(bytes memory input) internal pure returns (uint256 memoryAddress) {
-        internal
-        pure
-        returns (uint256 memoryAddress)
-    {
         assembly {
             memoryAddress := add(input, 32)
         }
@@ -65,10 +55,7 @@ library LibBytesV06 {
         uint256 dest,
         uint256 source,
         uint256 length
-    )
+    ) internal pure {
-        internal
-        pure
-    {
         if (length < 32) {
             // Handle a partial word by reading destination and masking
             // off the bits we are interested in.
@@ -120,7 +107,11 @@ library LibBytesV06 {
                     // Note: the first check is always true,
                     // this could have been a do-while loop.
                     // solhint-disable-next-line no-empty-blocks
-                    for {} lt(source, sEnd) {} {
+                    for {
+
+                    } lt(source, sEnd) {
+
+                    } {
                         mstore(dest, mload(source))
                         source := add(source, 32)
                         dest := add(dest, 32)
@@ -151,7 +142,11 @@ library LibBytesV06 {
                     // Note: the first check is always true,
                     // this could have been a do-while loop.
                     // solhint-disable-next-line no-empty-blocks
-                    for {} slt(dest, dEnd) {} {
+                    for {
+
+                    } slt(dest, dEnd) {
+
+                    } {
                         mstore(dEnd, mload(sEnd))
                         sEnd := sub(sEnd, 32)
                         dEnd := sub(dEnd, 32)
@@ -173,35 +168,31 @@ library LibBytesV06 {
         bytes memory b,
         uint256 from,
         uint256 to
-    )
+    ) internal pure returns (bytes memory result) {
-        internal
-        pure
-        returns (bytes memory result)
-    {
         // Ensure that the from and to positions are valid positions for a slice within
         // the byte array that is being used.
         if (from > to) {
-            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
+            LibRichErrorsV06.rrevert(
-                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
+                LibBytesRichErrorsV06.InvalidByteOperationError(
-                from,
+                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
-                to
+                    from,
-            ));
+                    to
+                )
+            );
         }
         if (to > b.length) {
-            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
+            LibRichErrorsV06.rrevert(
-                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
+                LibBytesRichErrorsV06.InvalidByteOperationError(
-                to,
+                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
-                b.length
+                    to,
-            ));
+                    b.length
+                )
+            );
         }
 
         // Create a new bytes structure and copy contents
         result = new bytes(to - from);
-        memCopy(
+        memCopy(result.contentAddress(), b.contentAddress() + from, result.length);
-            result.contentAddress(),
-            b.contentAddress() + from,
-            result.length
-        );
         return result;
     }
 
@@ -216,26 +207,26 @@ library LibBytesV06 {
         bytes memory b,
         uint256 from,
         uint256 to
-    )
+    ) internal pure returns (bytes memory result) {
-        internal
-        pure
-        returns (bytes memory result)
-    {
         // Ensure that the from and to positions are valid positions for a slice within
         // the byte array that is being used.
         if (from > to) {
-            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
+            LibRichErrorsV06.rrevert(
-                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
+                LibBytesRichErrorsV06.InvalidByteOperationError(
-                from,
+                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
-                to
+                    from,
-            ));
+                    to
+                )
+            );
         }
         if (to > b.length) {
-            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
+            LibRichErrorsV06.rrevert(
-                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
+                LibBytesRichErrorsV06.InvalidByteOperationError(
-                to,
+                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
-                b.length
+                    to,
-            ));
+                    b.length
+                )
+            );
         }
 
         // Create a new bytes structure around [from, to) in-place.
@@ -249,17 +240,15 @@ library LibBytesV06 {
     /// @dev Pops the last byte off of a byte array by modifying its length.
     /// @param b Byte array that will be modified.
     /// @return result The byte that was popped off.
-    function popLastByte(bytes memory b)
+    function popLastByte(bytes memory b) internal pure returns (bytes1 result) {
-        internal
-        pure
-        returns (bytes1 result)
-    {
         if (b.length == 0) {
-            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
+            LibRichErrorsV06.rrevert(
-                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,
+                LibBytesRichErrorsV06.InvalidByteOperationError(
-                b.length,
+                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,
-                0
+                    b.length,
-            ));
+                    0
+                )
+            );
         }
 
         // Store last byte.
@@ -277,14 +266,7 @@ library LibBytesV06 {
     /// @param lhs First byte array to compare.
     /// @param rhs Second byte array to compare.
     /// @return equal True if arrays are the same. False otherwise.
-    function equals(
+    function equals(bytes memory lhs, bytes memory rhs) internal pure returns (bool equal) {
-        bytes memory lhs,
-        bytes memory rhs
-    )
-        internal
-        pure
-        returns (bool equal)
-    {
         // Keccak gas cost is 30 + numWords * 6. This is a cheap way to compare.
         // We early exit on unequal lengths, but keccak would also correctly
         // handle this.
@@ -295,20 +277,15 @@ library LibBytesV06 {
     /// @param b Byte array containing an address.
     /// @param index Index in byte array of address.
     /// @return result address from byte array.
-    function readAddress(
+    function readAddress(bytes memory b, uint256 index) internal pure returns (address result) {
-        bytes memory b,
-        uint256 index
-    )
-        internal
-        pure
-        returns (address result)
-    {
         if (b.length < index + 20) {
-            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
+            LibRichErrorsV06.rrevert(
-                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
+                LibBytesRichErrorsV06.InvalidByteOperationError(
-                b.length,
+                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
-                index + 20 // 20 is length of address
+                    b.length,
-            ));
+                    index + 20 // 20 is length of address
+                )
+            );
         }
 
         // Add offset to index:
@@ -334,16 +311,15 @@ library LibBytesV06 {
         bytes memory b,
         uint256 index,
         address input
-    )
+    ) internal pure {
-        internal
-        pure
-    {
         if (b.length < index + 20) {
-            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
+            LibRichErrorsV06.rrevert(
-                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
+                LibBytesRichErrorsV06.InvalidByteOperationError(
-                b.length,
+                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
-                index + 20 // 20 is length of address
+                    b.length,
-            ));
+                    index + 20 // 20 is length of address
+                )
+            );
         }
 
         // Add offset to index:
@@ -379,20 +355,15 @@ library LibBytesV06 {
     /// @param b Byte array containing a bytes32 value.
     /// @param index Index in byte array of bytes32 value.
     /// @return result bytes32 value from byte array.
-    function readBytes32(
+    function readBytes32(bytes memory b, uint256 index) internal pure returns (bytes32 result) {
-        bytes memory b,
-        uint256 index
-    )
-        internal
-        pure
-        returns (bytes32 result)
-    {
         if (b.length < index + 32) {
-            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
+            LibRichErrorsV06.rrevert(
-                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
+                LibBytesRichErrorsV06.InvalidByteOperationError(
-                b.length,
+                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
-                index + 32
+                    b.length,
-            ));
+                    index + 32
+                )
+            );
         }
 
         // Arrays are prefixed by a 256 bit length parameter
@@ -413,16 +384,15 @@ library LibBytesV06 {
         bytes memory b,
         uint256 index,
         bytes32 input
-    )
+    ) internal pure {
-        internal
-        pure
-    {
         if (b.length < index + 32) {
-            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
+            LibRichErrorsV06.rrevert(
-                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
+                LibBytesRichErrorsV06.InvalidByteOperationError(
-                b.length,
+                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
-                index + 32
+                    b.length,
-            ));
+                    index + 32
+                )
+            );
         }
 
         // Arrays are prefixed by a 256 bit length parameter
@@ -438,14 +408,7 @@ library LibBytesV06 {
     /// @param b Byte array containing a uint256 value.
     /// @param index Index in byte array of uint256 value.
     /// @return result uint256 value from byte array.
-    function readUint256(
+    function readUint256(bytes memory b, uint256 index) internal pure returns (uint256 result) {
-        bytes memory b,
-        uint256 index
-    )
-        internal
-        pure
-        returns (uint256 result)
-    {
         result = uint256(readBytes32(b, index));
         return result;
     }
@@ -458,10 +421,7 @@ library LibBytesV06 {
         bytes memory b,
         uint256 index,
         uint256 input
-    )
+    ) internal pure {
-        internal
-        pure
-    {
         writeBytes32(b, index, bytes32(input));
     }
 
@@ -469,20 +429,15 @@ library LibBytesV06 {
     /// @param b Byte array containing a bytes4 value.
     /// @param index Index in byte array of bytes4 value.
     /// @return result bytes4 value from byte array.
-    function readBytes4(
+    function readBytes4(bytes memory b, uint256 index) internal pure returns (bytes4 result) {
-        bytes memory b,
-        uint256 index
-    )
-        internal
-        pure
-        returns (bytes4 result)
-    {
         if (b.length < index + 4) {
-            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
+            LibRichErrorsV06.rrevert(
-                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,
+                LibBytesRichErrorsV06.InvalidByteOperationError(
-                b.length,
+                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,
-                index + 4
+                    b.length,
-            ));
+                    index + 4
+                )
+            );
         }
 
         // Arrays are prefixed by a 32 byte length field
@@ -503,10 +458,7 @@ library LibBytesV06 {
     ///      Increasing length may lead to appending adjacent in-memory bytes to the end of the byte array.
     /// @param b Bytes array to write new length to.
     /// @param length New length of byte array.
-    function writeLength(bytes memory b, uint256 length)
+    function writeLength(bytes memory b, uint256 length) internal pure {
-        internal
-        pure
-    {
         assembly {
             mstore(b, length)
         }

contracts/utils/contracts/src/v06/LibMathV06.sol

@@ -23,9 +23,7 @@ import "./LibSafeMathV06.sol";
 import "./errors/LibRichErrorsV06.sol";
 import "./errors/LibMathRichErrorsV06.sol";
 
-
 library LibMathV06 {
-
     using LibSafeMathV06 for uint256;
 
     /// @dev Calculates partial value given a numerator and denominator rounded down.
@@ -38,21 +36,9 @@ library LibMathV06 {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (uint256 partialAmount) {
-        internal
+        if (isRoundingErrorFloor(numerator, denominator, target)) {
-        pure
+            LibRichErrorsV06.rrevert(LibMathRichErrorsV06.RoundingError(numerator, denominator, target));
-        returns (uint256 partialAmount)
-    {
-        if (isRoundingErrorFloor(
-                numerator,
-                denominator,
-                target
-        )) {
-            LibRichErrorsV06.rrevert(LibMathRichErrorsV06.RoundingError(
-                numerator,
-                denominator,
-                target
-            ));
         }
 
         partialAmount = numerator.safeMul(target).safeDiv(denominator);
@@ -69,29 +55,15 @@ library LibMathV06 {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (uint256 partialAmount) {
-        internal
+        if (isRoundingErrorCeil(numerator, denominator, target)) {
-        pure
+            LibRichErrorsV06.rrevert(LibMathRichErrorsV06.RoundingError(numerator, denominator, target));
-        returns (uint256 partialAmount)
-    {
-        if (isRoundingErrorCeil(
-                numerator,
-                denominator,
-                target
-        )) {
-            LibRichErrorsV06.rrevert(LibMathRichErrorsV06.RoundingError(
-                numerator,
-                denominator,
-                target
-            ));
         }
 
         // safeDiv computes `floor(a / b)`. We use the identity (a, b integer):
         //       ceil(a / b) = floor((a + b - 1) / b)
         // To implement `ceil(a / b)` using safeDiv.
-        partialAmount = numerator.safeMul(target)
+        partialAmount = numerator.safeMul(target).safeAdd(denominator.safeSub(1)).safeDiv(denominator);
-            .safeAdd(denominator.safeSub(1))
-            .safeDiv(denominator);
 
         return partialAmount;
     }
@@ -105,11 +77,7 @@ library LibMathV06 {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (uint256 partialAmount) {
-        internal
-        pure
-        returns (uint256 partialAmount)
-    {
         partialAmount = numerator.safeMul(target).safeDiv(denominator);
         return partialAmount;
     }
@@ -123,17 +91,11 @@ library LibMathV06 {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (uint256 partialAmount) {
-        internal
-        pure
-        returns (uint256 partialAmount)
-    {
         // safeDiv computes `floor(a / b)`. We use the identity (a, b integer):
         //       ceil(a / b) = floor((a + b - 1) / b)
         // To implement `ceil(a / b)` using safeDiv.
-        partialAmount = numerator.safeMul(target)
+        partialAmount = numerator.safeMul(target).safeAdd(denominator.safeSub(1)).safeDiv(denominator);
-            .safeAdd(denominator.safeSub(1))
-            .safeDiv(denominator);
 
         return partialAmount;
     }
@@ -147,11 +109,7 @@ library LibMathV06 {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (bool isError) {
-        internal
-        pure
-        returns (bool isError)
-    {
         if (denominator == 0) {
             LibRichErrorsV06.rrevert(LibMathRichErrorsV06.DivisionByZeroError());
         }
@@ -182,11 +140,7 @@ library LibMathV06 {
         //        1000 * remainder  <  numerator * target
         // so we have a rounding error iff:
         //        1000 * remainder  >=  numerator * target
-        uint256 remainder = mulmod(
+        uint256 remainder = mulmod(target, numerator, denominator);
-            target,
-            numerator,
-            denominator
-        );
         isError = remainder.safeMul(1000) >= numerator.safeMul(target);
         return isError;
     }
@@ -200,11 +154,7 @@ library LibMathV06 {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (bool isError) {
-        internal
-        pure
-        returns (bool isError)
-    {
         if (denominator == 0) {
             LibRichErrorsV06.rrevert(LibMathRichErrorsV06.DivisionByZeroError());
         }
@@ -217,11 +167,7 @@ library LibMathV06 {
             return false;
         }
         // Compute remainder as before
-        uint256 remainder = mulmod(
+        uint256 remainder = mulmod(target, numerator, denominator);
-            target,
-            numerator,
-            denominator
-        );
         remainder = denominator.safeSub(remainder) % denominator;
         isError = remainder.safeMul(1000) >= numerator.safeMul(target);
         return isError;

contracts/utils/contracts/src/v06/LibSafeMathV06.sol

@@ -22,183 +22,147 @@ pragma solidity ^0.6.5;
 import "./errors/LibRichErrorsV06.sol";
 import "./errors/LibSafeMathRichErrorsV06.sol";
 
-
 library LibSafeMathV06 {
-
+    function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
-    function safeMul(uint256 a, uint256 b)
-        internal
-        pure
-        returns (uint256)
-    {
         if (a == 0) {
             return 0;
         }
         uint256 c = a * b;
         if (c / a != b) {
-            LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
+            LibRichErrorsV06.rrevert(
-                LibSafeMathRichErrorsV06.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,
+                LibSafeMathRichErrorsV06.Uint256BinOpError(
-                a,
+                    LibSafeMathRichErrorsV06.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,
-                b
+                    a,
-            ));
+                    b
+                )
+            );
         }
         return c;
     }
 
-    function safeDiv(uint256 a, uint256 b)
+    function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
-        internal
-        pure
-        returns (uint256)
-    {
         if (b == 0) {
-            LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
+            LibRichErrorsV06.rrevert(
-                LibSafeMathRichErrorsV06.BinOpErrorCodes.DIVISION_BY_ZERO,
+                LibSafeMathRichErrorsV06.Uint256BinOpError(
-                a,
+                    LibSafeMathRichErrorsV06.BinOpErrorCodes.DIVISION_BY_ZERO,
-                b
+                    a,
-            ));
+                    b
+                )
+            );
         }
         uint256 c = a / b;
         return c;
     }
 
-    function safeSub(uint256 a, uint256 b)
+    function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
-        internal
-        pure
-        returns (uint256)
-    {
         if (b > a) {
-            LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
+            LibRichErrorsV06.rrevert(
-                LibSafeMathRichErrorsV06.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,
+                LibSafeMathRichErrorsV06.Uint256BinOpError(
-                a,
+                    LibSafeMathRichErrorsV06.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,
-                b
+                    a,
-            ));
+                    b
+                )
+            );
         }
         return a - b;
     }
 
-    function safeAdd(uint256 a, uint256 b)
+    function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
-        internal
-        pure
-        returns (uint256)
-    {
         uint256 c = a + b;
         if (c < a) {
-            LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
+            LibRichErrorsV06.rrevert(
-                LibSafeMathRichErrorsV06.BinOpErrorCodes.ADDITION_OVERFLOW,
+                LibSafeMathRichErrorsV06.Uint256BinOpError(
-                a,
+                    LibSafeMathRichErrorsV06.BinOpErrorCodes.ADDITION_OVERFLOW,
-                b
+                    a,
-            ));
+                    b
+                )
+            );
         }
         return c;
     }
 
-    function max256(uint256 a, uint256 b)
+    function max256(uint256 a, uint256 b) internal pure returns (uint256) {
-        internal
-        pure
-        returns (uint256)
-    {
         return a >= b ? a : b;
     }
 
-    function min256(uint256 a, uint256 b)
+    function min256(uint256 a, uint256 b) internal pure returns (uint256) {
-        internal
-        pure
-        returns (uint256)
-    {
         return a < b ? a : b;
     }
 
-    function safeMul128(uint128 a, uint128 b)
+    function safeMul128(uint128 a, uint128 b) internal pure returns (uint128) {
-        internal
-        pure
-        returns (uint128)
-    {
         if (a == 0) {
             return 0;
         }
         uint128 c = a * b;
         if (c / a != b) {
-            LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
+            LibRichErrorsV06.rrevert(
-                LibSafeMathRichErrorsV06.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,
+                LibSafeMathRichErrorsV06.Uint256BinOpError(
-                a,
+                    LibSafeMathRichErrorsV06.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,
-                b
+                    a,
-            ));
+                    b
+                )
+            );
         }
         return c;
     }
 
-    function safeDiv128(uint128 a, uint128 b)
+    function safeDiv128(uint128 a, uint128 b) internal pure returns (uint128) {
-        internal
-        pure
-        returns (uint128)
-    {
         if (b == 0) {
-            LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
+            LibRichErrorsV06.rrevert(
-                LibSafeMathRichErrorsV06.BinOpErrorCodes.DIVISION_BY_ZERO,
+                LibSafeMathRichErrorsV06.Uint256BinOpError(
-                a,
+                    LibSafeMathRichErrorsV06.BinOpErrorCodes.DIVISION_BY_ZERO,
-                b
+                    a,
-            ));
+                    b
+                )
+            );
         }
         uint128 c = a / b;
         return c;
     }
 
-    function safeSub128(uint128 a, uint128 b)
+    function safeSub128(uint128 a, uint128 b) internal pure returns (uint128) {
-        internal
-        pure
-        returns (uint128)
-    {
         if (b > a) {
-            LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
+            LibRichErrorsV06.rrevert(
-                LibSafeMathRichErrorsV06.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,
+                LibSafeMathRichErrorsV06.Uint256BinOpError(
-                a,
+                    LibSafeMathRichErrorsV06.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,
-                b
+                    a,
-            ));
+                    b
+                )
+            );
         }
         return a - b;
     }
 
-    function safeAdd128(uint128 a, uint128 b)
+    function safeAdd128(uint128 a, uint128 b) internal pure returns (uint128) {
-        internal
-        pure
-        returns (uint128)
-    {
         uint128 c = a + b;
         if (c < a) {
-            LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
+            LibRichErrorsV06.rrevert(
-                LibSafeMathRichErrorsV06.BinOpErrorCodes.ADDITION_OVERFLOW,
+                LibSafeMathRichErrorsV06.Uint256BinOpError(
-                a,
+                    LibSafeMathRichErrorsV06.BinOpErrorCodes.ADDITION_OVERFLOW,
-                b
+                    a,
-            ));
+                    b
+                )
+            );
         }
         return c;
     }
 
-    function max128(uint128 a, uint128 b)
+    function max128(uint128 a, uint128 b) internal pure returns (uint128) {
-        internal
-        pure
-        returns (uint128)
-    {
         return a >= b ? a : b;
     }
 
-    function min128(uint128 a, uint128 b)
+    function min128(uint128 a, uint128 b) internal pure returns (uint128) {
-        internal
-        pure
-        returns (uint128)
-    {
         return a < b ? a : b;
     }
 
-    function safeDowncastToUint128(uint256 a)
+    function safeDowncastToUint128(uint256 a) internal pure returns (uint128) {
-        internal
-        pure
-        returns (uint128)
-    {
         if (a > type(uint128).max) {
-            LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256DowncastError(
+            LibRichErrorsV06.rrevert(
-                LibSafeMathRichErrorsV06.DowncastErrorCodes.VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT128,
+                LibSafeMathRichErrorsV06.Uint256DowncastError(
-                a
+                    LibSafeMathRichErrorsV06.DowncastErrorCodes.VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT128,
-            ));
+                    a
+                )
+            );
         }
         return uint128(a);
     }

contracts/utils/contracts/src/v06/OwnableV06.sol

@@ -23,10 +23,7 @@ import "./interfaces/IOwnableV06.sol";
 import "./errors/LibRichErrorsV06.sol";
 import "./errors/LibOwnableRichErrorsV06.sol";
 
-
+contract OwnableV06 is IOwnableV06 {
-contract OwnableV06 is
-    IOwnableV06
-{
     /// @dev The owner of this contract.
     /// @return 0 The owner address.
     address public override owner;
@@ -42,11 +39,7 @@ contract OwnableV06 is
 
     /// @dev Change the owner of this contract.
     /// @param newOwner New owner address.
-    function transferOwnership(address newOwner)
+    function transferOwnership(address newOwner) public override onlyOwner {
-        public
-        override
-        onlyOwner
-    {
         if (newOwner == address(0)) {
             LibRichErrorsV06.rrevert(LibOwnableRichErrorsV06.TransferOwnerToZeroError());
         } else {
@@ -55,15 +48,9 @@ contract OwnableV06 is
         }
     }
 
-    function _assertSenderIsOwner()
+    function _assertSenderIsOwner() internal view {
-        internal
-        view
-    {
         if (msg.sender != owner) {
-            LibRichErrorsV06.rrevert(LibOwnableRichErrorsV06.OnlyOwnerError(
+            LibRichErrorsV06.rrevert(LibOwnableRichErrorsV06.OnlyOwnerError(msg.sender, owner));
-                msg.sender,
-                owner
-            ));
         }
     }
 }

contracts/utils/contracts/src/v06/ReentrancyGuardV06.sol

@@ -22,9 +22,7 @@ pragma solidity ^0.6.5;
 import "./errors/LibReentrancyGuardRichErrorsV06.sol";
 import "./errors/LibRichErrorsV06.sol";
 
-
 contract ReentrancyGuardV06 {
-
     // Locked state of mutex.
     bool private _locked = false;
 
@@ -36,22 +34,16 @@ contract ReentrancyGuardV06 {
         _unlockMutex();
     }
 
-    function _lockMutexOrThrowIfAlreadyLocked()
+    function _lockMutexOrThrowIfAlreadyLocked() internal {
-        internal
-    {
         // Ensure mutex is unlocked.
         if (_locked) {
-            LibRichErrorsV06.rrevert(
+            LibRichErrorsV06.rrevert(LibReentrancyGuardRichErrorsV06.IllegalReentrancyError());
-                LibReentrancyGuardRichErrorsV06.IllegalReentrancyError()
-            );
         }
         // Lock mutex.
         _locked = true;
     }
 
-    function _unlockMutex()
+    function _unlockMutex() internal {
-        internal
-    {
         // Unlock mutex.
         _locked = false;
     }

contracts/utils/contracts/src/v06/errors/LibAuthorizableRichErrorsV06.sol

@@ -19,102 +19,47 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibAuthorizableRichErrorsV06 {
-
     // bytes4(keccak256("AuthorizedAddressMismatchError(address,address)"))
-    bytes4 internal constant AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR =
+    bytes4 internal constant AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR = 0x140a84db;
-        0x140a84db;
 
     // bytes4(keccak256("IndexOutOfBoundsError(uint256,uint256)"))
-    bytes4 internal constant INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR =
+    bytes4 internal constant INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR = 0xe9f83771;
-        0xe9f83771;
 
     // bytes4(keccak256("SenderNotAuthorizedError(address)"))
-    bytes4 internal constant SENDER_NOT_AUTHORIZED_ERROR_SELECTOR =
+    bytes4 internal constant SENDER_NOT_AUTHORIZED_ERROR_SELECTOR = 0xb65a25b9;
-        0xb65a25b9;
 
     // bytes4(keccak256("TargetAlreadyAuthorizedError(address)"))
-    bytes4 internal constant TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR =
+    bytes4 internal constant TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR = 0xde16f1a0;
-        0xde16f1a0;
 
     // bytes4(keccak256("TargetNotAuthorizedError(address)"))
-    bytes4 internal constant TARGET_NOT_AUTHORIZED_ERROR_SELECTOR =
+    bytes4 internal constant TARGET_NOT_AUTHORIZED_ERROR_SELECTOR = 0xeb5108a2;
-        0xeb5108a2;
 
     // bytes4(keccak256("ZeroCantBeAuthorizedError()"))
-    bytes internal constant ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES =
+    bytes internal constant ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES = hex"57654fe4";
-        hex"57654fe4";
 
     // solhint-disable func-name-mixedcase
-    function AuthorizedAddressMismatchError(
+    function AuthorizedAddressMismatchError(address authorized, address target) internal pure returns (bytes memory) {
-        address authorized,
+        return abi.encodeWithSelector(AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR, authorized, target);
-        address target
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR,
-            authorized,
-            target
-        );
     }
 
-    function IndexOutOfBoundsError(
+    function IndexOutOfBoundsError(uint256 index, uint256 length) internal pure returns (bytes memory) {
-        uint256 index,
+        return abi.encodeWithSelector(INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR, index, length);
-        uint256 length
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR,
-            index,
-            length
-        );
     }
 
-    function SenderNotAuthorizedError(address sender)
+    function SenderNotAuthorizedError(address sender) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(SENDER_NOT_AUTHORIZED_ERROR_SELECTOR, sender);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            SENDER_NOT_AUTHORIZED_ERROR_SELECTOR,
-            sender
-        );
     }
 
-    function TargetAlreadyAuthorizedError(address target)
+    function TargetAlreadyAuthorizedError(address target) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR, target);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR,
-            target
-        );
     }
 
-    function TargetNotAuthorizedError(address target)
+    function TargetNotAuthorizedError(address target) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(TARGET_NOT_AUTHORIZED_ERROR_SELECTOR, target);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            TARGET_NOT_AUTHORIZED_ERROR_SELECTOR,
-            target
-        );
     }
 
-    function ZeroCantBeAuthorizedError()
+    function ZeroCantBeAuthorizedError() internal pure returns (bytes memory) {
-        internal
-        pure
-        returns (bytes memory)
-    {
         return ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES;
     }
 }

contracts/utils/contracts/src/v06/errors/LibBytesRichErrorsV06.sol

@@ -19,9 +19,7 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibBytesRichErrorsV06 {
-
     enum InvalidByteOperationErrorCodes {
         FromLessThanOrEqualsToRequired,
         ToLessThanOrEqualsLengthRequired,
@@ -34,24 +32,14 @@ library LibBytesRichErrorsV06 {
     }
 
     // bytes4(keccak256("InvalidByteOperationError(uint8,uint256,uint256)"))
-    bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR =
+    bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR = 0x28006595;
-        0x28006595;
 
     // solhint-disable func-name-mixedcase
     function InvalidByteOperationError(
         InvalidByteOperationErrorCodes errorCode,
         uint256 offset,
         uint256 required
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(INVALID_BYTE_OPERATION_ERROR_SELECTOR, errorCode, offset, required);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            INVALID_BYTE_OPERATION_ERROR_SELECTOR,
-            errorCode,
-            offset,
-            required
-        );
     }
 }

contracts/utils/contracts/src/v06/errors/LibMathRichErrorsV06.sol

@@ -19,23 +19,15 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibMathRichErrorsV06 {
-
     // bytes4(keccak256("DivisionByZeroError()"))
-    bytes internal constant DIVISION_BY_ZERO_ERROR =
+    bytes internal constant DIVISION_BY_ZERO_ERROR = hex"a791837c";
-        hex"a791837c";
 
     // bytes4(keccak256("RoundingError(uint256,uint256,uint256)"))
-    bytes4 internal constant ROUNDING_ERROR_SELECTOR =
+    bytes4 internal constant ROUNDING_ERROR_SELECTOR = 0x339f3de2;
-        0x339f3de2;
 
     // solhint-disable func-name-mixedcase
-    function DivisionByZeroError()
+    function DivisionByZeroError() internal pure returns (bytes memory) {
-        internal
-        pure
-        returns (bytes memory)
-    {
         return DIVISION_BY_ZERO_ERROR;
     }
 
@@ -43,16 +35,7 @@ library LibMathRichErrorsV06 {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(ROUNDING_ERROR_SELECTOR, numerator, denominator, target);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            ROUNDING_ERROR_SELECTOR,
-            numerator,
-            denominator,
-            target
-        );
     }
 }

contracts/utils/contracts/src/v06/errors/LibOwnableRichErrorsV06.sol

@@ -18,38 +18,19 @@
 */
 pragma solidity ^0.6.5;
 
-
 library LibOwnableRichErrorsV06 {
-
     // bytes4(keccak256("OnlyOwnerError(address,address)"))
-    bytes4 internal constant ONLY_OWNER_ERROR_SELECTOR =
+    bytes4 internal constant ONLY_OWNER_ERROR_SELECTOR = 0x1de45ad1;
-        0x1de45ad1;
 
     // bytes4(keccak256("TransferOwnerToZeroError()"))
-    bytes internal constant TRANSFER_OWNER_TO_ZERO_ERROR_BYTES =
+    bytes internal constant TRANSFER_OWNER_TO_ZERO_ERROR_BYTES = hex"e69edc3e";
-        hex"e69edc3e";
 
     // solhint-disable func-name-mixedcase
-    function OnlyOwnerError(
+    function OnlyOwnerError(address sender, address owner) internal pure returns (bytes memory) {
-        address sender,
+        return abi.encodeWithSelector(ONLY_OWNER_ERROR_SELECTOR, sender, owner);
-        address owner
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            ONLY_OWNER_ERROR_SELECTOR,
-            sender,
-            owner
-        );
     }
 
-    function TransferOwnerToZeroError()
+    function TransferOwnerToZeroError() internal pure returns (bytes memory) {
-        internal
-        pure
-        returns (bytes memory)
-    {
         return TRANSFER_OWNER_TO_ZERO_ERROR_BYTES;
     }
 }

contracts/utils/contracts/src/v06/errors/LibReentrancyGuardRichErrorsV06.sol

@@ -19,19 +19,12 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibReentrancyGuardRichErrorsV06 {
-
     // bytes4(keccak256("IllegalReentrancyError()"))
-    bytes internal constant ILLEGAL_REENTRANCY_ERROR_SELECTOR_BYTES =
+    bytes internal constant ILLEGAL_REENTRANCY_ERROR_SELECTOR_BYTES = hex"0c3b823f";
-        hex"0c3b823f";
 
     // solhint-disable func-name-mixedcase
-    function IllegalReentrancyError()
+    function IllegalReentrancyError() internal pure returns (bytes memory) {
-        internal
-        pure
-        returns (bytes memory)
-    {
         return ILLEGAL_REENTRANCY_ERROR_SELECTOR_BYTES;
     }
 }

contracts/utils/contracts/src/v06/errors/LibRichErrorsV06.sol

@@ -19,9 +19,7 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibRichErrorsV06 {
-
     // bytes4(keccak256("Error(string)"))
     bytes4 internal constant STANDARD_ERROR_SELECTOR = 0x08c379a0;
 
@@ -31,24 +29,15 @@ library LibRichErrorsV06 {
     ///      solidity statement. It has the function signature `Error(string)`.
     /// @param message The error string.
     /// @return The ABI encoded error.
-    function StandardError(string memory message)
+    function StandardError(string memory message) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(STANDARD_ERROR_SELECTOR, bytes(message));
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            STANDARD_ERROR_SELECTOR,
-            bytes(message)
-        );
     }
+
     // solhint-enable func-name-mixedcase
 
     /// @dev Reverts an encoded rich revert reason `errorData`.
     /// @param errorData ABI encoded error data.
-    function rrevert(bytes memory errorData)
+    function rrevert(bytes memory errorData) internal pure {
-        internal
-        pure
-    {
         assembly {
             revert(add(errorData, 0x20), mload(errorData))
         }

contracts/utils/contracts/src/v06/errors/LibSafeMathRichErrorsV06.sol

@@ -19,16 +19,12 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibSafeMathRichErrorsV06 {
-
     // bytes4(keccak256("Uint256BinOpError(uint8,uint256,uint256)"))
-    bytes4 internal constant UINT256_BINOP_ERROR_SELECTOR =
+    bytes4 internal constant UINT256_BINOP_ERROR_SELECTOR = 0xe946c1bb;
-        0xe946c1bb;
 
     // bytes4(keccak256("Uint256DowncastError(uint8,uint256)"))
-    bytes4 internal constant UINT256_DOWNCAST_ERROR_SELECTOR =
+    bytes4 internal constant UINT256_DOWNCAST_ERROR_SELECTOR = 0xc996af7b;
-        0xc996af7b;
 
     enum BinOpErrorCodes {
         ADDITION_OVERFLOW,
@@ -49,31 +45,11 @@ library LibSafeMathRichErrorsV06 {
         BinOpErrorCodes errorCode,
         uint256 a,
         uint256 b
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(UINT256_BINOP_ERROR_SELECTOR, errorCode, a, b);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            UINT256_BINOP_ERROR_SELECTOR,
-            errorCode,
-            a,
-            b
-        );
     }
 
-    function Uint256DowncastError(
+    function Uint256DowncastError(DowncastErrorCodes errorCode, uint256 a) internal pure returns (bytes memory) {
-        DowncastErrorCodes errorCode,
+        return abi.encodeWithSelector(UINT256_DOWNCAST_ERROR_SELECTOR, errorCode, a);
-        uint256 a
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            UINT256_DOWNCAST_ERROR_SELECTOR,
-            errorCode,
-            a
-        );
     }
 }

contracts/utils/contracts/src/v06/interfaces/IAuthorizableV06.sol

@@ -21,47 +21,29 @@ pragma solidity ^0.6.5;
 
 import "./IOwnableV06.sol";
 
-
+interface IAuthorizableV06 is IOwnableV06 {
-interface IAuthorizableV06 is
-    IOwnableV06
-{
     // Event logged when a new address is authorized.
-    event AuthorizedAddressAdded(
+    event AuthorizedAddressAdded(address indexed target, address indexed caller);
-        address indexed target,
-        address indexed caller
-    );
 
     // Event logged when a currently authorized address is unauthorized.
-    event AuthorizedAddressRemoved(
+    event AuthorizedAddressRemoved(address indexed target, address indexed caller);
-        address indexed target,
-        address indexed caller
-    );
 
     /// @dev Authorizes an address.
     /// @param target Address to authorize.
-    function addAuthorizedAddress(address target)
+    function addAuthorizedAddress(address target) external;
-        external;
 
     /// @dev Removes authorizion of an address.
     /// @param target Address to remove authorization from.
-    function removeAuthorizedAddress(address target)
+    function removeAuthorizedAddress(address target) external;
-        external;
 
     /// @dev Removes authorizion of an address.
     /// @param target Address to remove authorization from.
     /// @param index Index of target in authorities array.
-    function removeAuthorizedAddressAtIndex(
+    function removeAuthorizedAddressAtIndex(address target, uint256 index) external;
-        address target,
-        uint256 index
-    )
-        external;
 
     /// @dev Gets all authorized addresses.
     /// @return authorizedAddresses Array of authorized addresses.
-    function getAuthorizedAddresses()
+    function getAuthorizedAddresses() external view returns (address[] memory authorizedAddresses);
-        external
-        view
-        returns (address[] memory authorizedAddresses);
 
     /// @dev Whether an adderss is authorized to call privileged functions.
     /// @param addr Address to query.
@@ -72,5 +54,4 @@ interface IAuthorizableV06 is
     /// @param idx Index of authorized address.
     /// @return addr Authorized address.
     function authorities(uint256 idx) external view returns (address addr);
-
 }

contracts/utils/contracts/src/v06/interfaces/IOwnableV06.sol

@@ -19,9 +19,7 @@
 
 pragma solidity ^0.6.5;
 
-
 interface IOwnableV06 {
-
     /// @dev Emitted by Ownable when ownership is transferred.
     /// @param previousOwner The previous owner of the contract.
     /// @param newOwner The new owner of the contract.

contracts/utils/contracts/test/TestAuthorizable.sol

@@ -20,14 +20,7 @@ pragma solidity ^0.5.9;
 
 import "../src/Authorizable.sol";
 
-
 // solhint-disable no-empty-blocks
-contract TestAuthorizable is
+contract TestAuthorizable is Authorizable {
-    Authorizable
+    function onlyAuthorizedFn() external view onlyAuthorized {}
-{
-    function onlyAuthorizedFn()
-        external
-        view
-        onlyAuthorized
-    {}
 }

contracts/utils/contracts/test/TestLibAddress.sol

@@ -20,16 +20,10 @@ pragma solidity ^0.5.9;
 
 import "../src/LibAddress.sol";
 
-
 contract TestLibAddress {
-
     using LibAddress for address;
 
-    function externalIsContract(address account)
+    function externalIsContract(address account) external view returns (bool) {
-        external
-        view
-        returns (bool)
-    {
         return account.isContract();
     }
 }

contracts/utils/contracts/test/TestLibAddressArray.sol

@@ -20,9 +20,7 @@ pragma solidity ^0.5.5;
 
 import "../src/LibAddressArray.sol";
 
-
 contract TestLibAddressArray {
-
     using LibAddressArray for address[];
 
     /// @dev Append a new address to an array of addresses.
@@ -83,11 +81,7 @@ contract TestLibAddressArray {
     /// @param addressArray Array of addresses.
     /// @param target Address to search for in array.
     /// @return True if the addressArray contains the target.
-    function publicContains(address[] memory addressArray, address target)
+    function publicContains(address[] memory addressArray, address target) public pure returns (bool success) {
-        public
-        pure
-        returns (bool success)
-    {
         return addressArray.contains(target);
     }
 
@@ -102,5 +96,4 @@ contract TestLibAddressArray {
     {
         (success, index) = addressArray.indexOf(target);
     }
-
 }

contracts/utils/contracts/test/TestLibBytes.sol

@@ -20,19 +20,13 @@ pragma solidity ^0.5.9;
 
 import "../src/LibBytes.sol";
 
-
 contract TestLibBytes {
-
     using LibBytes for bytes;
 
     /// @dev Pops the last byte off of a byte array by modifying its length.
     /// @param b Byte array that will be modified.
     /// @return The byte that was popped off.
-    function publicPopLastByte(bytes memory b)
+    function publicPopLastByte(bytes memory b) public pure returns (bytes memory, bytes1 result) {
-        public
-        pure
-        returns (bytes memory, bytes1 result)
-    {
         result = b.popLastByte();
         return (b, result);
     }
@@ -41,20 +35,12 @@ contract TestLibBytes {
     /// @param lhs First byte array to compare.
     /// @param rhs Second byte array to compare.
     /// @return True if arrays are the same. False otherwise.
-    function publicEquals(bytes memory lhs, bytes memory rhs)
+    function publicEquals(bytes memory lhs, bytes memory rhs) public pure returns (bool equal) {
-        public
-        pure
-        returns (bool equal)
-    {
         equal = lhs.equals(rhs);
         return equal;
     }
 
-    function publicEqualsPop1(bytes memory lhs, bytes memory rhs)
+    function publicEqualsPop1(bytes memory lhs, bytes memory rhs) public pure returns (bool equal) {
-        public
-        pure
-        returns (bool equal)
-    {
         lhs.popLastByte();
         rhs.popLastByte();
         equal = lhs.equals(rhs);
@@ -65,14 +51,7 @@ contract TestLibBytes {
     /// @param b Byte array containing an address.
     /// @param index Index in byte array of address.
     /// @return address from byte array.
-    function publicReadAddress(
+    function publicReadAddress(bytes memory b, uint256 index) public pure returns (address result) {
-        bytes memory b,
-        uint256 index
-    )
-        public
-        pure
-        returns (address result)
-    {
         result = b.readAddress(index);
         return result;
     }
@@ -85,11 +64,7 @@ contract TestLibBytes {
         bytes memory b,
         uint256 index,
         address input
-    )
+    ) public pure returns (bytes memory) {
-        public
-        pure
-        returns (bytes memory)
-    {
         b.writeAddress(index, input);
         return b;
     }
@@ -98,14 +73,7 @@ contract TestLibBytes {
     /// @param b Byte array containing a bytes32 value.
     /// @param index Index in byte array of bytes32 value.
     /// @return bytes32 value from byte array.
-    function publicReadBytes32(
+    function publicReadBytes32(bytes memory b, uint256 index) public pure returns (bytes32 result) {
-        bytes memory b,
-        uint256 index
-    )
-        public
-        pure
-        returns (bytes32 result)
-    {
         result = b.readBytes32(index);
         return result;
     }
@@ -118,11 +86,7 @@ contract TestLibBytes {
         bytes memory b,
         uint256 index,
         bytes32 input
-    )
+    ) public pure returns (bytes memory) {
-        public
-        pure
-        returns (bytes memory)
-    {
         b.writeBytes32(index, input);
         return b;
     }
@@ -131,14 +95,7 @@ contract TestLibBytes {
     /// @param b Byte array containing a uint256 value.
     /// @param index Index in byte array of uint256 value.
     /// @return uint256 value from byte array.
-    function publicReadUint256(
+    function publicReadUint256(bytes memory b, uint256 index) public pure returns (uint256 result) {
-        bytes memory b,
-        uint256 index
-    )
-        public
-        pure
-        returns (uint256 result)
-    {
         result = b.readUint256(index);
         return result;
     }
@@ -151,11 +108,7 @@ contract TestLibBytes {
         bytes memory b,
         uint256 index,
         uint256 input
-    )
+    ) public pure returns (bytes memory) {
-        public
-        pure
-        returns (bytes memory)
-    {
         b.writeUint256(index, input);
         return b;
     }
@@ -164,14 +117,7 @@ contract TestLibBytes {
     /// @param b Byte array containing a bytes4 value.
     /// @param index Index in byte array of bytes4 value.
     /// @return bytes4 value from byte array.
-    function publicReadBytes4(
+    function publicReadBytes4(bytes memory b, uint256 index) public pure returns (bytes4 result) {
-        bytes memory b,
-        uint256 index
-    )
-        public
-        pure
-        returns (bytes4 result)
-    {
         result = b.readBytes4(index);
         return result;
     }
@@ -186,12 +132,8 @@ contract TestLibBytes {
         bytes memory mem,
         uint256 dest,
         uint256 source,
-        uint256 length
+        uint256 length // not external, we need input in memory
-    )
+    ) public pure returns (bytes memory) {
-        public // not external, we need input in memory
-        pure
-        returns (bytes memory)
-    {
         // Sanity check. Overflows are not checked.
         require(source + length <= mem.length);
         require(dest + length <= mem.length);
@@ -215,11 +157,7 @@ contract TestLibBytes {
         bytes memory b,
         uint256 from,
         uint256 to
-    )
+    ) public pure returns (bytes memory result, bytes memory original) {
-        public
-        pure
-        returns (bytes memory result, bytes memory original)
-    {
         result = LibBytes.slice(b, from, to);
         return (result, b);
     }
@@ -234,11 +172,7 @@ contract TestLibBytes {
         bytes memory b,
         uint256 from,
         uint256 to
-    )
+    ) public pure returns (bytes memory result, bytes memory original) {
-        public
-        pure
-        returns (bytes memory result, bytes memory original)
-    {
         result = LibBytes.sliceDestructive(b, from, to);
         return (result, b);
     }
@@ -254,24 +188,14 @@ contract TestLibBytes {
         bytes memory b,
         uint256 length,
         bytes memory extraBytes
-    )
+    ) public pure returns (bytes memory) {
-        public
-        pure
-        returns (bytes memory)
-    {
         uint256 bEnd = b.contentAddress() + b.length;
         LibBytes.memCopy(bEnd, extraBytes.contentAddress(), extraBytes.length);
         b.writeLength(length);
         return b;
     }
 
-    function assertBytesUnchangedAfterLengthReset(
+    function assertBytesUnchangedAfterLengthReset(bytes memory b, uint256 tempLength) public pure {
-        bytes memory b,
-        uint256 tempLength
-    )
-        public
-        pure
-    {
         uint256 length = b.length;
         bytes memory bCopy = b.slice(0, length);
         b.writeLength(tempLength);

contracts/utils/contracts/test/TestLibEIP712.sol

@@ -20,32 +20,17 @@ pragma solidity ^0.5.9;
 
 import "../src/LibEIP712.sol";
 
-
 contract TestLibEIP712 {
-
     function externalHashEIP712DomainSeperator(
         string calldata name,
         string calldata version,
         uint256 chainid,
         address verifyingcontractaddress
-    )
+    ) external pure returns (bytes32) {
-        external
+        return LibEIP712.hashEIP712Domain(name, version, chainid, verifyingcontractaddress);
-        pure
-        returns (bytes32)
-    {
-        return LibEIP712.hashEIP712Domain(
-            name,
-            version,
-            chainid,
-            verifyingcontractaddress
-        );
     }
 
-    function externalHashEIP712Message(bytes32 eip712DomainHash, bytes32 hashStruct)
+    function externalHashEIP712Message(bytes32 eip712DomainHash, bytes32 hashStruct) external pure returns (bytes32) {
-        external
-        pure
-        returns (bytes32)
-    {
         return LibEIP712.hashEIP712Message(eip712DomainHash, hashStruct);
     }
 }

contracts/utils/contracts/test/TestLibMath.sol

@@ -21,9 +21,7 @@ pragma experimental ABIEncoderV2;
 
 import "../src/LibMath.sol";
 
-
 contract TestLibMath {
-
     /// @dev Calculates partial value given a numerator and denominator.
     ///      Reverts if rounding error is >= 0.1%
     /// @param numerator Numerator.
@@ -34,11 +32,7 @@ contract TestLibMath {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) public pure returns (uint256 partialAmount) {
-        public
-        pure
-        returns (uint256 partialAmount)
-    {
         return LibMath.safeGetPartialAmountFloor(numerator, denominator, target);
     }
 
@@ -52,11 +46,7 @@ contract TestLibMath {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) public pure returns (uint256 partialAmount) {
-        public
-        pure
-        returns (uint256 partialAmount)
-    {
         return LibMath.safeGetPartialAmountCeil(numerator, denominator, target);
     }
 
@@ -69,11 +59,7 @@ contract TestLibMath {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) public pure returns (uint256 partialAmount) {
-        public
-        pure
-        returns (uint256 partialAmount)
-    {
         return LibMath.getPartialAmountFloor(numerator, denominator, target);
     }
 
@@ -86,11 +72,7 @@ contract TestLibMath {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) public pure returns (uint256 partialAmount) {
-        public
-        pure
-        returns (uint256 partialAmount)
-    {
         return LibMath.getPartialAmountCeil(numerator, denominator, target);
     }
 
@@ -103,11 +85,7 @@ contract TestLibMath {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) public pure returns (bool isError) {
-        public
-        pure
-        returns (bool isError)
-    {
         return LibMath.isRoundingErrorFloor(numerator, denominator, target);
     }
 
@@ -120,11 +98,7 @@ contract TestLibMath {
         uint256 numerator,
         uint256 denominator,
         uint256 target
-    )
+    ) public pure returns (bool isError) {
-        public
-        pure
-        returns (bool isError)
-    {
         return LibMath.isRoundingErrorCeil(numerator, denominator, target);
     }
 }

contracts/utils/contracts/test/TestLibRichErrors.sol

@@ -20,13 +20,8 @@ pragma solidity ^0.5.9;
 
 import "../src/LibRichErrors.sol";
 
-
 contract TestLibRichErrors {
-
+    function externalRRevert(bytes calldata errorData) external pure {
-    function externalRRevert(bytes calldata errorData)
-        external
-        pure
-    {
         LibRichErrors.rrevert(errorData);
     }
 }

contracts/utils/contracts/test/TestLibSafeMath.sol

@@ -20,56 +20,30 @@ pragma solidity ^0.5.9;
 
 import "../src/LibSafeMath.sol";
 
-
 contract TestLibSafeMath {
-
     using LibSafeMath for uint256;
 
-    function externalSafeMul(uint256 a, uint256 b)
+    function externalSafeMul(uint256 a, uint256 b) external pure returns (uint256) {
-        external
-        pure
-        returns (uint256)
-    {
         return a.safeMul(b);
     }
 
-    function externalSafeDiv(uint256 a, uint256 b)
+    function externalSafeDiv(uint256 a, uint256 b) external pure returns (uint256) {
-        external
-        pure
-        returns (uint256)
-    {
         return a.safeDiv(b);
     }
 
-    function externalSafeSub(uint256 a, uint256 b)
+    function externalSafeSub(uint256 a, uint256 b) external pure returns (uint256) {
-        external
-        pure
-        returns (uint256)
-    {
         return a.safeSub(b);
     }
 
-    function externalSafeAdd(uint256 a, uint256 b)
+    function externalSafeAdd(uint256 a, uint256 b) external pure returns (uint256) {
-        external
-        pure
-        returns (uint256)
-    {
         return a.safeAdd(b);
     }
 
-    function externalMaxUint256(uint256 a, uint256 b)
+    function externalMaxUint256(uint256 a, uint256 b) external pure returns (uint256) {
-        external
-        pure
-        returns (uint256)
-    {
         return a.max256(b);
     }
 
-    function externalMinUint256(uint256 a, uint256 b)
+    function externalMinUint256(uint256 a, uint256 b) external pure returns (uint256) {
-        external
-        pure
-        returns (uint256)
-    {
         return a.min256(b);
     }
 }

contracts/utils/contracts/test/TestLogDecoding.sol

@@ -20,35 +20,23 @@ pragma solidity ^0.5.5;
 
 import "./TestLogDecodingDownstream.sol";
 
-
 contract TestLogDecoding {
-
     /// @dev arbitrary event; fields to not matter.
-    event TestEvent(
+    event TestEvent(uint256 foo, bytes bar, string car);
-        uint256 foo,
-        bytes bar,
-        string car
-    );
 
     /// @dev Emits a local event
-    function emitEvent()
+    function emitEvent() public {
-        public
+        emit TestEvent(256, hex"1234", "4321");
-    {
-        emit TestEvent(256, hex'1234', "4321");
     }
 
     /// @dev Emits an event in a downstream contract
-    function emitEventDownstream()
+    function emitEventDownstream() public {
-        public
-    {
         TestLogDecodingDownstream testLogDecodingDownstream = new TestLogDecodingDownstream();
         ITestLogDecodingDownstream(testLogDecodingDownstream).emitEvent();
     }
 
     /// @dev Emits a local event and a downstream event
-    function emitEventsLocalAndDownstream()
+    function emitEventsLocalAndDownstream() public {
-        public
-    {
         emitEvent();
         emitEventDownstream();
     }

contracts/utils/contracts/test/TestLogDecodingDownstream.sol

@@ -18,31 +18,20 @@
 
 pragma solidity ^0.5.5;
 
-
 contract ITestLogDecodingDownstream {
-
     /// @dev Emits a local event
     function emitEvent() external;
 }
 
-
+contract TestLogDecodingDownstream is ITestLogDecodingDownstream {
-contract TestLogDecodingDownstream is
-    ITestLogDecodingDownstream
-{
-
     /// @dev event with fields different than those in `TestLogDecoding.TestEvent`
     /// Note: do not include this in the interface
     /// For testing, we want to emit an event that is
     /// not known by the calling contract.
-    event TestEvent2(
+    event TestEvent2(uint256 lorem, string ipsum);
-        uint256 lorem,
-        string ipsum
-    );
 
     /// @dev Emits a local event
-    function emitEvent()
+    function emitEvent() external {
-        external
-    {
         emit TestEvent2(256, "4321");
     }
 }

contracts/utils/contracts/test/TestOwnable.sol

@@ -2,16 +2,8 @@ pragma solidity ^0.5.9;
 
 import "../src/Ownable.sol";
 
-
+contract TestOwnable is Ownable {
-contract TestOwnable is
+    function externalOnlyOwner() external view onlyOwner returns (bool) {
-    Ownable
-{
-    function externalOnlyOwner()
-        external
-        onlyOwner
-        view
-        returns (bool)
-    {
         return true;
     }
 }

contracts/utils/contracts/test/TestReentrancyGuard.sol

@@ -20,18 +20,11 @@ pragma solidity ^0.5.9;
 
 import "../src/ReentrancyGuard.sol";
 
-
+contract TestReentrancyGuard is ReentrancyGuard {
-contract TestReentrancyGuard is
-    ReentrancyGuard
-{
     /// @dev Exposes the nonReentrant modifier publicly.
     /// @param shouldBeAttacked True if the contract should be attacked.
     /// @return True if successful.
-    function guarded(bool shouldBeAttacked)
+    function guarded(bool shouldBeAttacked) external nonReentrant returns (bool) {
-        external
-        nonReentrant
-        returns (bool)
-    {
         if (shouldBeAttacked) {
             return this.exploitive();
         } else {
@@ -41,20 +34,13 @@ contract TestReentrancyGuard is
 
     /// @dev This is a function that will reenter the current contract.
     /// @return True if successful.
-    function exploitive()
+    function exploitive() external returns (bool) {
-        external
-        returns (bool)
-    {
         return this.guarded(true);
     }
 
     /// @dev This is a function that will not reenter the current contract.
     /// @return True if successful.
-    function nonExploitive()
+    function nonExploitive() external pure returns (bool) {
-        external
-        pure
-        returns (bool)
-    {
         return true;
     }
 }

contracts/utils/contracts/test/TestRefundable.sol

@@ -20,59 +20,29 @@ pragma solidity ^0.5.9;
 
 import "../src/Refundable.sol";
 
-
+contract TestRefundable is Refundable {
-contract TestRefundable is
+    function refundNonZeroBalanceExternal() external payable {
-    Refundable
-{
-    function refundNonZeroBalanceExternal()
-        external
-        payable
-    {
         _refundNonZeroBalance();
     }
 
-    function setShouldNotRefund(bool shouldNotRefundNew)
+    function setShouldNotRefund(bool shouldNotRefundNew) external {
-        external
-    {
         _shouldNotRefund = shouldNotRefundNew;
     }
 
-    function getShouldNotRefund()
+    function getShouldNotRefund() external view returns (bool) {
-        external
-        view
-        returns (bool)
-    {
         return _shouldNotRefund;
     }
 
-    function refundFinalBalanceFunction()
+    function refundFinalBalanceFunction() public payable refundFinalBalance {} // solhint-disable-line no-empty-blocks
-        public
-        payable
-        refundFinalBalance
-    {} // solhint-disable-line no-empty-blocks
 
-    function disableRefundUntilEndFunction()
+    function disableRefundUntilEndFunction() public payable disableRefundUntilEnd {} // solhint-disable-line no-empty-blocks
-        public
-        payable
-        disableRefundUntilEnd
-    {} // solhint-disable-line no-empty-blocks
 
-    function nestedDisableRefundUntilEndFunction()
+    function nestedDisableRefundUntilEndFunction() public payable disableRefundUntilEnd returns (uint256) {
-        public
-        payable
-        disableRefundUntilEnd
-        returns (uint256)
-    {
         disableRefundUntilEndFunction();
         return address(this).balance;
     }
 
-    function mixedRefundModifierFunction()
+    function mixedRefundModifierFunction() public payable disableRefundUntilEnd returns (uint256) {
-        public
-        payable
-        disableRefundUntilEnd
-        returns (uint256)
-    {
         refundFinalBalanceFunction();
         return address(this).balance;
     }

contracts/utils/contracts/test/TestRefundableReceiver.sol

@@ -20,16 +20,11 @@ pragma solidity ^0.5.9;
 
 import "./TestRefundable.sol";
 
-
 contract TestRefundableReceiver {
-
     /// @dev A payable fallback function is necessary to receive refunds from the `TestRefundable` contract.
     ///      This function ensures that zero value is not sent to the contract, which tests the feature of
     ///      of the `refundNonzeroBalance` that doesn't transfer if the balance is zero.
-    function ()
+    function() external payable {
-        external
-        payable
-    {
         // Ensure that a value of zero was not transferred to the contract.
         require(msg.value != 0, "Zero value should not be sent to this contract.");
     }
@@ -37,10 +32,7 @@ contract TestRefundableReceiver {
     /// @dev This function tests the behavior of the `refundNonzeroBalance` function by checking whether or
     ///      not the `callCounter` state variable changes after the `refundNonzeroBalance` is called.
     /// @param testRefundable The TestRefundable that should be tested against.
-    function testRefundNonZeroBalance(TestRefundable testRefundable)
+    function testRefundNonZeroBalance(TestRefundable testRefundable) external payable {
-        external
-        payable
-    {
         // Call `refundNonzeroBalance()` and forward all of the eth sent to the contract.
         testRefundable.refundNonZeroBalanceExternal.value(msg.value)();
 
@@ -58,13 +50,7 @@ contract TestRefundableReceiver {
     ///      remains unaltered after the function call.
     /// @param testRefundable The TestRefundable that should be tested against.
     /// @param shouldNotRefund The value that shouldNotRefund should be set to before the call to TestRefundable.
-    function testRefundFinalBalance(
+    function testRefundFinalBalance(TestRefundable testRefundable, bool shouldNotRefund) external payable {
-        TestRefundable testRefundable,
-        bool shouldNotRefund
-    )
-        external
-        payable
-    {
         // Set `shouldNotRefund` to the specified bool.
         testRefundable.setShouldNotRefund(shouldNotRefund);
 
@@ -82,13 +68,7 @@ contract TestRefundableReceiver {
     ///      remains unaltered after the function call.
     /// @param testRefundable The TestRefundable that should be tested against.
     /// @param shouldNotRefund The value that shouldNotRefund should be set to before the call to TestRefundable.
-    function testDisableRefundUntilEnd(
+    function testDisableRefundUntilEnd(TestRefundable testRefundable, bool shouldNotRefund) external payable {
-        TestRefundable testRefundable,
-        bool shouldNotRefund
-    )
-        external
-        payable
-    {
         // Set `shouldNotRefund` to the specified bool.
         testRefundable.setShouldNotRefund(shouldNotRefund);
 
@@ -105,13 +85,7 @@ contract TestRefundableReceiver {
     ///      to verify that both the inner and outer modifiers worked correctly.
     /// @param testRefundable The TestRefundable that should be tested against.
     /// @param shouldNotRefund The value that shouldNotRefund should be set to before the call to TestRefundable.
-    function testNestedDisableRefundUntilEnd(
+    function testNestedDisableRefundUntilEnd(TestRefundable testRefundable, bool shouldNotRefund) external payable {
-        TestRefundable testRefundable,
-        bool shouldNotRefund
-    )
-        external
-        payable
-    {
         // Set `shouldNotRefund` to the specified bool.
         testRefundable.setShouldNotRefund(shouldNotRefund);
 
@@ -132,13 +106,7 @@ contract TestRefundableReceiver {
     ///      to verify that both the inner and outer modifiers worked correctly.
     /// @param testRefundable The TestRefundable that should be tested against.
     /// @param shouldNotRefund The value that shouldNotRefund should be set to before the call to TestRefundable.
-    function testMixedRefunds(
+    function testMixedRefunds(TestRefundable testRefundable, bool shouldNotRefund) external payable {
-        TestRefundable testRefundable,
-        bool shouldNotRefund
-    )
-        external
-        payable
-    {
         // Set `shouldNotRefund` to the specified bool.
         testRefundable.setShouldNotRefund(shouldNotRefund);
 
@@ -158,12 +126,7 @@ contract TestRefundableReceiver {
     ///      refundable contract and verifies that the `shouldNotRefund` value remains unaltered.
     /// @param testRefundable The TestRefundable that should be tested against.
     /// @param shouldNotRefund The value that shouldNotRefund was set to before the call to TestRefundable.
-    function requireCorrectFinalBalancesAndState(
+    function requireCorrectFinalBalancesAndState(TestRefundable testRefundable, bool shouldNotRefund) internal {
-        TestRefundable testRefundable,
-        bool shouldNotRefund
-    )
-        internal
-    {
         // If `shouldNotRefund` was true, then this contract should have a balance of zero,
         // and `testRefundable` should have a balance of `msg.value`. Otherwise, the opposite
         // should be true.

contracts/zero-ex/contracts/src/IZeroEx.sol

@@ -38,7 +38,6 @@ import "./features/interfaces/IERC721OrdersFeature.sol";
 import "./features/interfaces/IERC1155OrdersFeature.sol";
 import "./features/interfaces/IERC165Feature.sol";
 
-
 /// @dev Interface for a fully featured Exchange Proxy.
 interface IZeroEx is
     IOwnableFeature,

contracts/zero-ex/contracts/src/ZeroEx.sol

@@ -26,7 +26,6 @@ import "./features/BootstrapFeature.sol";
 import "./storage/LibProxyStorage.sol";
 import "./errors/LibProxyRichErrors.sol";
 
-
 /// @dev An extensible proxy contract that serves as a universal entry point for
 ///      interacting with the 0x protocol.
 contract ZeroEx {
@@ -41,8 +40,7 @@ contract ZeroEx {
         // Temporarily create and register the bootstrap feature.
         // It will deregister itself after `bootstrap()` has been called.
         BootstrapFeature bootstrap = new BootstrapFeature(bootstrapper);
-        LibProxyStorage.getStorage().impls[bootstrap.bootstrap.selector] =
+        LibProxyStorage.getStorage().impls[bootstrap.bootstrap.selector] = address(bootstrap);
-            address(bootstrap);
     }
 
     // solhint-disable state-visibility
@@ -70,23 +68,23 @@ contract ZeroEx {
     /// @dev Get the implementation contract of a registered function.
     /// @param selector The function selector.
     /// @return impl The implementation contract address.
-    function getFunctionImplementation(bytes4 selector)
+    function getFunctionImplementation(bytes4 selector) public view returns (address impl) {
-        public
-        view
-        returns (address impl)
-    {
         return LibProxyStorage.getStorage().impls[selector];
     }
 
     /// @dev Revert with arbitrary bytes.
     /// @param data Revert data.
     function _revertWithData(bytes memory data) private pure {
-        assembly { revert(add(data, 32), mload(data)) }
+        assembly {
+            revert(add(data, 32), mload(data))
+        }
     }
 
     /// @dev Return with arbitrary bytes.
     /// @param data Return data.
     function _returnWithData(bytes memory data) private pure {
-        assembly { return(add(data, 32), mload(data)) }
+        assembly {
+            return(add(data, 32), mload(data))
+        }
     }
 }

contracts/zero-ex/contracts/src/ZeroExOptimized.sol

@@ -34,18 +34,15 @@ contract ZeroExOptimized {
         // Temporarily create and register the bootstrap feature.
         // It will deregister itself after `bootstrap()` has been called.
         BootstrapFeature bootstrap = new BootstrapFeature(bootstrapper);
-        LibProxyStorage.getStorage().impls[bootstrap.bootstrap.selector] =
+        LibProxyStorage.getStorage().impls[bootstrap.bootstrap.selector] = address(bootstrap);
-            address(bootstrap);
     }
 
-
     // solhint-disable state-visibility
 
     /// @dev Forwards calls to the appropriate implementation contract.
     fallback() external payable {
         // This is used in assembly below as impls_slot.
-        mapping(bytes4 => address) storage impls =
+        mapping(bytes4 => address) storage impls = LibProxyStorage.getStorage().impls;
-            LibProxyStorage.getStorage().impls;
 
         assembly {
             let cdlen := calldatasize()
@@ -75,12 +72,7 @@ contract ZeroExOptimized {
                 revert(0, 0x24)
             }
 
-            let success := delegatecall(
+            let success := delegatecall(gas(), delegate, 0x40, cdlen, 0, 0)
-                gas(),
-                delegate,
-                0x40, cdlen,
-                0, 0
-            )
             let rdlen := returndatasize()
             returndatacopy(0, 0, rdlen)
             if success {

contracts/zero-ex/contracts/src/errors/LibCommonRichErrors.sol

@@ -19,31 +19,19 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibCommonRichErrors {
-
     // solhint-disable func-name-mixedcase
 
-    function OnlyCallableBySelfError(address sender)
+    function OnlyCallableBySelfError(address sender) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(bytes4(keccak256("OnlyCallableBySelfError(address)")), sender);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("OnlyCallableBySelfError(address)")),
-            sender
-        );
     }
 
-    function IllegalReentrancyError(bytes4 selector, uint256 reentrancyFlags)
+    function IllegalReentrancyError(bytes4 selector, uint256 reentrancyFlags) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("IllegalReentrancyError(bytes4,uint256)")),
-    {
+                selector,
-        return abi.encodeWithSelector(
+                reentrancyFlags
-            bytes4(keccak256("IllegalReentrancyError(bytes4,uint256)")),
+            );
-            selector,
-            reentrancyFlags
-        );
     }
 }

contracts/zero-ex/contracts/src/errors/LibLiquidityProviderRichErrors.sol

@@ -19,9 +19,7 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibLiquidityProviderRichErrors {
-
     // solhint-disable func-name-mixedcase
 
     function LiquidityProviderIncompleteSellError(
@@ -31,19 +29,18 @@ library LibLiquidityProviderRichErrors {
         uint256 sellAmount,
         uint256 boughtAmount,
         uint256 minBuyAmount
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(
-    {
+                    keccak256("LiquidityProviderIncompleteSellError(address,address,address,uint256,uint256,uint256)")
-        return abi.encodeWithSelector(
+                ),
-            bytes4(keccak256("LiquidityProviderIncompleteSellError(address,address,address,uint256,uint256,uint256)")),
+                providerAddress,
-            providerAddress,
+                makerToken,
-            makerToken,
+                takerToken,
-            takerToken,
+                sellAmount,
-            sellAmount,
+                boughtAmount,
-            boughtAmount,
+                minBuyAmount
-            minBuyAmount
+            );
-        );
     }
 }

contracts/zero-ex/contracts/src/errors/LibMetaTransactionsRichErrors.sol

@@ -19,73 +19,61 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibMetaTransactionsRichErrors {
-
     // solhint-disable func-name-mixedcase
 
-    function InvalidMetaTransactionsArrayLengthsError(
+    function InvalidMetaTransactionsArrayLengthsError(uint256 mtxCount, uint256 signatureCount)
-        uint256 mtxCount,
-        uint256 signatureCount
-    )
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encodeWithSelector(
+        return
-            bytes4(keccak256("InvalidMetaTransactionsArrayLengthsError(uint256,uint256)")),
+            abi.encodeWithSelector(
-            mtxCount,
+                bytes4(keccak256("InvalidMetaTransactionsArrayLengthsError(uint256,uint256)")),
-            signatureCount
+                mtxCount,
-        );
+                signatureCount
+            );
     }
 
-    function MetaTransactionUnsupportedFunctionError(
+    function MetaTransactionUnsupportedFunctionError(bytes32 mtxHash, bytes4 selector)
-        bytes32 mtxHash,
-        bytes4 selector
-    )
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encodeWithSelector(
+        return
-            bytes4(keccak256("MetaTransactionUnsupportedFunctionError(bytes32,bytes4)")),
+            abi.encodeWithSelector(
-            mtxHash,
+                bytes4(keccak256("MetaTransactionUnsupportedFunctionError(bytes32,bytes4)")),
-            selector
+                mtxHash,
-        );
+                selector
+            );
     }
 
     function MetaTransactionWrongSenderError(
         bytes32 mtxHash,
         address sender,
         address expectedSender
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("MetaTransactionWrongSenderError(bytes32,address,address)")),
-    {
+                mtxHash,
-        return abi.encodeWithSelector(
+                sender,
-            bytes4(keccak256("MetaTransactionWrongSenderError(bytes32,address,address)")),
+                expectedSender
-            mtxHash,
+            );
-            sender,
-            expectedSender
-        );
     }
 
     function MetaTransactionExpiredError(
         bytes32 mtxHash,
         uint256 time,
         uint256 expirationTime
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("MetaTransactionExpiredError(bytes32,uint256,uint256)")),
-    {
+                mtxHash,
-        return abi.encodeWithSelector(
+                time,
-            bytes4(keccak256("MetaTransactionExpiredError(bytes32,uint256,uint256)")),
+                expirationTime
-            mtxHash,
+            );
-            time,
-            expirationTime
-        );
     }
 
     function MetaTransactionGasPriceError(
@@ -93,83 +81,69 @@ library LibMetaTransactionsRichErrors {
         uint256 gasPrice,
         uint256 minGasPrice,
         uint256 maxGasPrice
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("MetaTransactionGasPriceError(bytes32,uint256,uint256,uint256)")),
-    {
+                mtxHash,
-        return abi.encodeWithSelector(
+                gasPrice,
-            bytes4(keccak256("MetaTransactionGasPriceError(bytes32,uint256,uint256,uint256)")),
+                minGasPrice,
-            mtxHash,
+                maxGasPrice
-            gasPrice,
+            );
-            minGasPrice,
-            maxGasPrice
-        );
     }
 
     function MetaTransactionInsufficientEthError(
         bytes32 mtxHash,
         uint256 ethBalance,
         uint256 ethRequired
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("MetaTransactionInsufficientEthError(bytes32,uint256,uint256)")),
-    {
+                mtxHash,
-        return abi.encodeWithSelector(
+                ethBalance,
-            bytes4(keccak256("MetaTransactionInsufficientEthError(bytes32,uint256,uint256)")),
+                ethRequired
-            mtxHash,
+            );
-            ethBalance,
-            ethRequired
-        );
     }
 
     function MetaTransactionInvalidSignatureError(
         bytes32 mtxHash,
         bytes memory signature,
         bytes memory errData
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("MetaTransactionInvalidSignatureError(bytes32,bytes,bytes)")),
-    {
+                mtxHash,
-        return abi.encodeWithSelector(
+                signature,
-            bytes4(keccak256("MetaTransactionInvalidSignatureError(bytes32,bytes,bytes)")),
+                errData
-            mtxHash,
+            );
-            signature,
-            errData
-        );
     }
 
-    function MetaTransactionAlreadyExecutedError(
+    function MetaTransactionAlreadyExecutedError(bytes32 mtxHash, uint256 executedBlockNumber)
-        bytes32 mtxHash,
-        uint256 executedBlockNumber
-    )
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encodeWithSelector(
+        return
-            bytes4(keccak256("MetaTransactionAlreadyExecutedError(bytes32,uint256)")),
+            abi.encodeWithSelector(
-            mtxHash,
+                bytes4(keccak256("MetaTransactionAlreadyExecutedError(bytes32,uint256)")),
-            executedBlockNumber
+                mtxHash,
-        );
+                executedBlockNumber
+            );
     }
 
     function MetaTransactionCallFailedError(
         bytes32 mtxHash,
         bytes memory callData,
         bytes memory returnData
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("MetaTransactionCallFailedError(bytes32,bytes,bytes)")),
-    {
+                mtxHash,
-        return abi.encodeWithSelector(
+                callData,
-            bytes4(keccak256("MetaTransactionCallFailedError(bytes32,bytes,bytes)")),
+                returnData
-            mtxHash,
+            );
-            callData,
-            returnData
-        );
     }
 }

contracts/zero-ex/contracts/src/errors/LibNFTOrdersRichErrors.sol

@@ -19,176 +19,81 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibNFTOrdersRichErrors {
-
     // solhint-disable func-name-mixedcase
 
-    function OverspentEthError(
+    function OverspentEthError(uint256 ethSpent, uint256 ethAvailable) internal pure returns (bytes memory) {
-        uint256 ethSpent,
+        return abi.encodeWithSelector(bytes4(keccak256("OverspentEthError(uint256,uint256)")), ethSpent, ethAvailable);
-        uint256 ethAvailable
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("OverspentEthError(uint256,uint256)")),
-            ethSpent,
-            ethAvailable
-        );
     }
 
-    function InsufficientEthError(
+    function InsufficientEthError(uint256 ethAvailable, uint256 orderAmount) internal pure returns (bytes memory) {
-        uint256 ethAvailable,
+        return
-        uint256 orderAmount
+            abi.encodeWithSelector(
-    )
+                bytes4(keccak256("InsufficientEthError(uint256,uint256)")),
-        internal
+                ethAvailable,
-        pure
+                orderAmount
-        returns (bytes memory)
+            );
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("InsufficientEthError(uint256,uint256)")),
-            ethAvailable,
-            orderAmount
-        );
     }
 
-    function ERC721TokenMismatchError(
+    function ERC721TokenMismatchError(address token1, address token2) internal pure returns (bytes memory) {
-        address token1,
+        return abi.encodeWithSelector(bytes4(keccak256("ERC721TokenMismatchError(address,address)")), token1, token2);
-        address token2
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("ERC721TokenMismatchError(address,address)")),
-            token1,
-            token2
-        );
     }
 
-    function ERC1155TokenMismatchError(
+    function ERC1155TokenMismatchError(address token1, address token2) internal pure returns (bytes memory) {
-        address token1,
+        return abi.encodeWithSelector(bytes4(keccak256("ERC1155TokenMismatchError(address,address)")), token1, token2);
-        address token2
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("ERC1155TokenMismatchError(address,address)")),
-            token1,
-            token2
-        );
     }
 
-    function ERC20TokenMismatchError(
+    function ERC20TokenMismatchError(address token1, address token2) internal pure returns (bytes memory) {
-        address token1,
+        return abi.encodeWithSelector(bytes4(keccak256("ERC20TokenMismatchError(address,address)")), token1, token2);
-        address token2
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("ERC20TokenMismatchError(address,address)")),
-            token1,
-            token2
-        );
     }
 
-    function NegativeSpreadError(
+    function NegativeSpreadError(uint256 sellOrderAmount, uint256 buyOrderAmount) internal pure returns (bytes memory) {
-        uint256 sellOrderAmount,
+        return
-        uint256 buyOrderAmount
+            abi.encodeWithSelector(
-    )
+                bytes4(keccak256("NegativeSpreadError(uint256,uint256)")),
-        internal
+                sellOrderAmount,
-        pure
+                buyOrderAmount
-        returns (bytes memory)
+            );
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("NegativeSpreadError(uint256,uint256)")),
-            sellOrderAmount,
-            buyOrderAmount
-        );
     }
 
-    function SellOrderFeesExceedSpreadError(
+    function SellOrderFeesExceedSpreadError(uint256 sellOrderFees, uint256 spread)
-        uint256 sellOrderFees,
-        uint256 spread
-    )
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encodeWithSelector(
+        return
-            bytes4(keccak256("SellOrderFeesExceedSpreadError(uint256,uint256)")),
+            abi.encodeWithSelector(
-            sellOrderFees,
+                bytes4(keccak256("SellOrderFeesExceedSpreadError(uint256,uint256)")),
-            spread
+                sellOrderFees,
-        );
+                spread
+            );
     }
 
-    function OnlyTakerError(
+    function OnlyTakerError(address sender, address taker) internal pure returns (bytes memory) {
-        address sender,
+        return abi.encodeWithSelector(bytes4(keccak256("OnlyTakerError(address,address)")), sender, taker);
-        address taker
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("OnlyTakerError(address,address)")),
-            sender,
-            taker
-        );
     }
 
-    function InvalidSignerError(
+    function InvalidSignerError(address maker, address signer) internal pure returns (bytes memory) {
-        address maker,
+        return abi.encodeWithSelector(bytes4(keccak256("InvalidSignerError(address,address)")), maker, signer);
-        address signer
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("InvalidSignerError(address,address)")),
-            maker,
-            signer
-        );
     }
 
     function OrderNotFillableError(
         address maker,
         uint256 nonce,
         uint8 orderStatus
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("OrderNotFillableError(address,uint256,uint8)")),
-    {
+                maker,
-        return abi.encodeWithSelector(
+                nonce,
-            bytes4(keccak256("OrderNotFillableError(address,uint256,uint8)")),
+                orderStatus
-            maker,
+            );
-            nonce,
-            orderStatus
-        );
     }
 
-    function TokenIdMismatchError(
+    function TokenIdMismatchError(uint256 tokenId, uint256 orderTokenId) internal pure returns (bytes memory) {
-        uint256 tokenId,
+        return
-        uint256 orderTokenId
+            abi.encodeWithSelector(bytes4(keccak256("TokenIdMismatchError(uint256,uint256)")), tokenId, orderTokenId);
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("TokenIdMismatchError(uint256,uint256)")),
-            tokenId,
-            orderTokenId
-        );
     }
 
     function PropertyValidationFailedError(
@@ -197,33 +102,28 @@ library LibNFTOrdersRichErrors {
         uint256 tokenId,
         bytes memory propertyData,
         bytes memory errorData
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("PropertyValidationFailedError(address,address,uint256,bytes,bytes)")),
-    {
+                propertyValidator,
-        return abi.encodeWithSelector(
+                token,
-            bytes4(keccak256("PropertyValidationFailedError(address,address,uint256,bytes,bytes)")),
+                tokenId,
-            propertyValidator,
+                propertyData,
-            token,
+                errorData
-            tokenId,
+            );
-            propertyData,
-            errorData
-        );
     }
 
-    function ExceedsRemainingOrderAmount(
+    function ExceedsRemainingOrderAmount(uint128 remainingOrderAmount, uint128 fillAmount)
-        uint128 remainingOrderAmount,
-        uint128 fillAmount
-    )
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encodeWithSelector(
+        return
-            bytes4(keccak256("ExceedsRemainingOrderAmount(uint128,uint128)")),
+            abi.encodeWithSelector(
-            remainingOrderAmount,
+                bytes4(keccak256("ExceedsRemainingOrderAmount(uint128,uint128)")),
-            fillAmount
+                remainingOrderAmount,
-        );
+                fillAmount
+            );
     }
 }

contracts/zero-ex/contracts/src/errors/LibNativeOrdersRichErrors.sol

@@ -19,187 +19,131 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibNativeOrdersRichErrors {
-
     // solhint-disable func-name-mixedcase
 
-    function ProtocolFeeRefundFailed(
+    function ProtocolFeeRefundFailed(address receiver, uint256 refundAmount) internal pure returns (bytes memory) {
-        address receiver,
+        return
-        uint256 refundAmount
+            abi.encodeWithSelector(
-    )
+                bytes4(keccak256("ProtocolFeeRefundFailed(address,uint256)")),
-        internal
+                receiver,
-        pure
+                refundAmount
-        returns (bytes memory)
+            );
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("ProtocolFeeRefundFailed(address,uint256)")),
-            receiver,
-            refundAmount
-        );
     }
 
     function OrderNotFillableByOriginError(
         bytes32 orderHash,
         address txOrigin,
         address orderTxOrigin
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("OrderNotFillableByOriginError(bytes32,address,address)")),
-    {
+                orderHash,
-        return abi.encodeWithSelector(
+                txOrigin,
-            bytes4(keccak256("OrderNotFillableByOriginError(bytes32,address,address)")),
+                orderTxOrigin
-            orderHash,
+            );
-            txOrigin,
-            orderTxOrigin
-        );
     }
 
-    function OrderNotFillableError(
+    function OrderNotFillableError(bytes32 orderHash, uint8 orderStatus) internal pure returns (bytes memory) {
-        bytes32 orderHash,
+        return
-        uint8 orderStatus
+            abi.encodeWithSelector(bytes4(keccak256("OrderNotFillableError(bytes32,uint8)")), orderHash, orderStatus);
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("OrderNotFillableError(bytes32,uint8)")),
-            orderHash,
-            orderStatus
-        );
     }
 
     function OrderNotSignedByMakerError(
         bytes32 orderHash,
         address signer,
         address maker
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("OrderNotSignedByMakerError(bytes32,address,address)")),
-    {
+                orderHash,
-        return abi.encodeWithSelector(
+                signer,
-            bytes4(keccak256("OrderNotSignedByMakerError(bytes32,address,address)")),
+                maker
-            orderHash,
+            );
-            signer,
-            maker
-        );
     }
 
-    function InvalidSignerError(
+    function InvalidSignerError(address maker, address signer) internal pure returns (bytes memory) {
-        address maker,
+        return abi.encodeWithSelector(bytes4(keccak256("InvalidSignerError(address,address)")), maker, signer);
-        address signer
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("InvalidSignerError(address,address)")),
-            maker,
-            signer
-        );
     }
 
     function OrderNotFillableBySenderError(
         bytes32 orderHash,
         address sender,
         address orderSender
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("OrderNotFillableBySenderError(bytes32,address,address)")),
-    {
+                orderHash,
-        return abi.encodeWithSelector(
+                sender,
-            bytes4(keccak256("OrderNotFillableBySenderError(bytes32,address,address)")),
+                orderSender
-            orderHash,
+            );
-            sender,
-            orderSender
-        );
     }
 
     function OrderNotFillableByTakerError(
         bytes32 orderHash,
         address taker,
         address orderTaker
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("OrderNotFillableByTakerError(bytes32,address,address)")),
-    {
+                orderHash,
-        return abi.encodeWithSelector(
+                taker,
-            bytes4(keccak256("OrderNotFillableByTakerError(bytes32,address,address)")),
+                orderTaker
-            orderHash,
+            );
-            taker,
-            orderTaker
-        );
     }
 
-    function CancelSaltTooLowError(
+    function CancelSaltTooLowError(uint256 minValidSalt, uint256 oldMinValidSalt) internal pure returns (bytes memory) {
-        uint256 minValidSalt,
+        return
-        uint256 oldMinValidSalt
+            abi.encodeWithSelector(
-    )
+                bytes4(keccak256("CancelSaltTooLowError(uint256,uint256)")),
-        internal
+                minValidSalt,
-        pure
+                oldMinValidSalt
-        returns (bytes memory)
+            );
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("CancelSaltTooLowError(uint256,uint256)")),
-            minValidSalt,
-            oldMinValidSalt
-        );
     }
 
     function FillOrKillFailedError(
         bytes32 orderHash,
         uint256 takerTokenFilledAmount,
         uint256 takerTokenFillAmount
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("FillOrKillFailedError(bytes32,uint256,uint256)")),
-    {
+                orderHash,
-        return abi.encodeWithSelector(
+                takerTokenFilledAmount,
-            bytes4(keccak256("FillOrKillFailedError(bytes32,uint256,uint256)")),
+                takerTokenFillAmount
-            orderHash,
+            );
-            takerTokenFilledAmount,
-            takerTokenFillAmount
-        );
     }
 
     function OnlyOrderMakerAllowed(
         bytes32 orderHash,
         address sender,
         address maker
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("OnlyOrderMakerAllowed(bytes32,address,address)")),
-    {
+                orderHash,
-        return abi.encodeWithSelector(
+                sender,
-            bytes4(keccak256("OnlyOrderMakerAllowed(bytes32,address,address)")),
+                maker
-            orderHash,
+            );
-            sender,
-            maker
-        );
     }
 
     function BatchFillIncompleteError(
         bytes32 orderHash,
         uint256 takerTokenFilledAmount,
         uint256 takerTokenFillAmount
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("BatchFillIncompleteError(bytes32,uint256,uint256)")),
-    {
+                orderHash,
-        return abi.encodeWithSelector(
+                takerTokenFilledAmount,
-            bytes4(keccak256("BatchFillIncompleteError(bytes32,uint256,uint256)")),
+                takerTokenFillAmount
-            orderHash,
+            );
-            takerTokenFilledAmount,
-            takerTokenFillAmount
-        );
     }
 }

contracts/zero-ex/contracts/src/errors/LibOwnableRichErrors.sol

@@ -19,45 +19,18 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibOwnableRichErrors {
-
     // solhint-disable func-name-mixedcase
 
-    function OnlyOwnerError(
+    function OnlyOwnerError(address sender, address owner) internal pure returns (bytes memory) {
-        address sender,
+        return abi.encodeWithSelector(bytes4(keccak256("OnlyOwnerError(address,address)")), sender, owner);
-        address owner
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("OnlyOwnerError(address,address)")),
-            sender,
-            owner
-        );
     }
 
-    function TransferOwnerToZeroError()
+    function TransferOwnerToZeroError() internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(bytes4(keccak256("TransferOwnerToZeroError()")));
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("TransferOwnerToZeroError()"))
-        );
     }
 
-    function MigrateCallFailedError(address target, bytes memory resultData)
+    function MigrateCallFailedError(address target, bytes memory resultData) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(bytes4(keccak256("MigrateCallFailedError(address,bytes)")), target, resultData);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("MigrateCallFailedError(address,bytes)")),
-            target,
-            resultData
-        );
     }
 }

contracts/zero-ex/contracts/src/errors/LibProxyRichErrors.sol

@@ -19,55 +19,23 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibProxyRichErrors {
-
     // solhint-disable func-name-mixedcase
 
-    function NotImplementedError(bytes4 selector)
+    function NotImplementedError(bytes4 selector) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(bytes4(keccak256("NotImplementedError(bytes4)")), selector);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("NotImplementedError(bytes4)")),
-            selector
-        );
     }
 
-    function InvalidBootstrapCallerError(address actual, address expected)
+    function InvalidBootstrapCallerError(address actual, address expected) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(bytes4(keccak256("InvalidBootstrapCallerError(address,address)")), actual, expected);
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("InvalidBootstrapCallerError(address,address)")),
-            actual,
-            expected
-        );
     }
 
-    function InvalidDieCallerError(address actual, address expected)
+    function InvalidDieCallerError(address actual, address expected) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(bytes4(keccak256("InvalidDieCallerError(address,address)")), actual, expected);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("InvalidDieCallerError(address,address)")),
-            actual,
-            expected
-        );
     }
 
-    function BootstrapCallFailedError(address target, bytes memory resultData)
+    function BootstrapCallFailedError(address target, bytes memory resultData) internal pure returns (bytes memory) {
-        internal
+        return abi.encodeWithSelector(bytes4(keccak256("BootstrapCallFailedError(address,bytes)")), target, resultData);
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("BootstrapCallFailedError(address,bytes)")),
-            target,
-            resultData
-        );
     }
 }

contracts/zero-ex/contracts/src/errors/LibSignatureRichErrors.sol

@@ -19,9 +19,7 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibSignatureRichErrors {
-
     enum SignatureValidationErrorCodes {
         ALWAYS_INVALID,
         INVALID_LENGTH,
@@ -38,32 +36,22 @@ library LibSignatureRichErrors {
         bytes32 hash,
         address signerAddress,
         bytes memory signature
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("SignatureValidationError(uint8,bytes32,address,bytes)")),
-    {
+                code,
-        return abi.encodeWithSelector(
+                hash,
-            bytes4(keccak256("SignatureValidationError(uint8,bytes32,address,bytes)")),
+                signerAddress,
-            code,
+                signature
-            hash,
+            );
-            signerAddress,
-            signature
-        );
     }
 
-    function SignatureValidationError(
+    function SignatureValidationError(SignatureValidationErrorCodes code, bytes32 hash)
-        SignatureValidationErrorCodes code,
-        bytes32 hash
-    )
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encodeWithSelector(
+        return abi.encodeWithSelector(bytes4(keccak256("SignatureValidationError(uint8,bytes32)")), code, hash);
-            bytes4(keccak256("SignatureValidationError(uint8,bytes32)")),
-            code,
-            hash
-        );
     }
 }

contracts/zero-ex/contracts/src/errors/LibSimpleFunctionRegistryRichErrors.sol

@@ -19,20 +19,15 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibSimpleFunctionRegistryRichErrors {
-
     // solhint-disable func-name-mixedcase
 
-    function NotInRollbackHistoryError(bytes4 selector, address targetImpl)
+    function NotInRollbackHistoryError(bytes4 selector, address targetImpl) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("NotInRollbackHistoryError(bytes4,address)")),
-    {
+                selector,
-        return abi.encodeWithSelector(
+                targetImpl
-            bytes4(keccak256("NotInRollbackHistoryError(bytes4,address)")),
+            );
-            selector,
-            targetImpl
-        );
     }
 }

contracts/zero-ex/contracts/src/errors/LibTransformERC20RichErrors.sol

@@ -19,105 +19,77 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibTransformERC20RichErrors {
-
     // solhint-disable func-name-mixedcase,separate-by-one-line-in-contract
 
-    function InsufficientEthAttachedError(
+    function InsufficientEthAttachedError(uint256 ethAttached, uint256 ethNeeded) internal pure returns (bytes memory) {
-        uint256 ethAttached,
+        return
-        uint256 ethNeeded
+            abi.encodeWithSelector(
-    )
+                bytes4(keccak256("InsufficientEthAttachedError(uint256,uint256)")),
-        internal
+                ethAttached,
-        pure
+                ethNeeded
-        returns (bytes memory)
+            );
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("InsufficientEthAttachedError(uint256,uint256)")),
-            ethAttached,
-            ethNeeded
-        );
     }
 
     function IncompleteTransformERC20Error(
         address outputToken,
         uint256 outputTokenAmount,
         uint256 minOutputTokenAmount
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("IncompleteTransformERC20Error(address,uint256,uint256)")),
-    {
+                outputToken,
-        return abi.encodeWithSelector(
+                outputTokenAmount,
-            bytes4(keccak256("IncompleteTransformERC20Error(address,uint256,uint256)")),
+                minOutputTokenAmount
-            outputToken,
+            );
-            outputTokenAmount,
-            minOutputTokenAmount
-        );
     }
 
-    function NegativeTransformERC20OutputError(
+    function NegativeTransformERC20OutputError(address outputToken, uint256 outputTokenLostAmount)
-        address outputToken,
-        uint256 outputTokenLostAmount
-    )
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encodeWithSelector(
+        return
-            bytes4(keccak256("NegativeTransformERC20OutputError(address,uint256)")),
+            abi.encodeWithSelector(
-            outputToken,
+                bytes4(keccak256("NegativeTransformERC20OutputError(address,uint256)")),
-            outputTokenLostAmount
+                outputToken,
-        );
+                outputTokenLostAmount
+            );
     }
 
     function TransformerFailedError(
         address transformer,
         bytes memory transformerData,
         bytes memory resultData
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("TransformerFailedError(address,bytes,bytes)")),
-    {
+                transformer,
-        return abi.encodeWithSelector(
+                transformerData,
-            bytes4(keccak256("TransformerFailedError(address,bytes,bytes)")),
+                resultData
-            transformer,
+            );
-            transformerData,
-            resultData
-        );
     }
 
     // Common Transformer errors ///////////////////////////////////////////////
 
-    function OnlyCallableByDeployerError(
+    function OnlyCallableByDeployerError(address caller, address deployer) internal pure returns (bytes memory) {
-        address caller,
+        return
-        address deployer
+            abi.encodeWithSelector(bytes4(keccak256("OnlyCallableByDeployerError(address,address)")), caller, deployer);
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("OnlyCallableByDeployerError(address,address)")),
-            caller,
-            deployer
-        );
     }
 
-    function InvalidExecutionContextError(
+    function InvalidExecutionContextError(address actualContext, address expectedContext)
-        address actualContext,
-        address expectedContext
-    )
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encodeWithSelector(
+        return
-            bytes4(keccak256("InvalidExecutionContextError(address,address)")),
+            abi.encodeWithSelector(
-            actualContext,
+                bytes4(keccak256("InvalidExecutionContextError(address,address)")),
-            expectedContext
+                actualContext,
-        );
+                expectedContext
+            );
     }
 
     enum InvalidTransformDataErrorCode {
@@ -125,19 +97,17 @@ library LibTransformERC20RichErrors {
         INVALID_ARRAY_LENGTH
     }
 
-    function InvalidTransformDataError(
+    function InvalidTransformDataError(InvalidTransformDataErrorCode errorCode, bytes memory transformData)
-        InvalidTransformDataErrorCode errorCode,
-        bytes memory transformData
-    )
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encodeWithSelector(
+        return
-            bytes4(keccak256("InvalidTransformDataError(uint8,bytes)")),
+            abi.encodeWithSelector(
-            errorCode,
+                bytes4(keccak256("InvalidTransformDataError(uint8,bytes)")),
-            transformData
+                errorCode,
-        );
+                transformData
+            );
     }
 
     // FillQuoteTransformer errors /////////////////////////////////////////////
@@ -146,89 +116,57 @@ library LibTransformERC20RichErrors {
         address sellToken,
         uint256 soldAmount,
         uint256 sellAmount
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("IncompleteFillSellQuoteError(address,uint256,uint256)")),
-    {
+                sellToken,
-        return abi.encodeWithSelector(
+                soldAmount,
-            bytes4(keccak256("IncompleteFillSellQuoteError(address,uint256,uint256)")),
+                sellAmount
-            sellToken,
+            );
-            soldAmount,
-            sellAmount
-        );
     }
 
     function IncompleteFillBuyQuoteError(
         address buyToken,
         uint256 boughtAmount,
         uint256 buyAmount
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("IncompleteFillBuyQuoteError(address,uint256,uint256)")),
-    {
+                buyToken,
-        return abi.encodeWithSelector(
+                boughtAmount,
-            bytes4(keccak256("IncompleteFillBuyQuoteError(address,uint256,uint256)")),
+                buyAmount
-            buyToken,
+            );
-            boughtAmount,
-            buyAmount
-        );
     }
 
-    function InsufficientTakerTokenError(
+    function InsufficientTakerTokenError(uint256 tokenBalance, uint256 tokensNeeded)
-        uint256 tokenBalance,
-        uint256 tokensNeeded
-    )
         internal
         pure
         returns (bytes memory)
     {
-        return abi.encodeWithSelector(
+        return
-            bytes4(keccak256("InsufficientTakerTokenError(uint256,uint256)")),
+            abi.encodeWithSelector(
-            tokenBalance,
+                bytes4(keccak256("InsufficientTakerTokenError(uint256,uint256)")),
-            tokensNeeded
+                tokenBalance,
-        );
+                tokensNeeded
+            );
     }
 
-    function InsufficientProtocolFeeError(
+    function InsufficientProtocolFeeError(uint256 ethBalance, uint256 ethNeeded) internal pure returns (bytes memory) {
-        uint256 ethBalance,
+        return
-        uint256 ethNeeded
+            abi.encodeWithSelector(
-    )
+                bytes4(keccak256("InsufficientProtocolFeeError(uint256,uint256)")),
-        internal
+                ethBalance,
-        pure
+                ethNeeded
-        returns (bytes memory)
+            );
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("InsufficientProtocolFeeError(uint256,uint256)")),
-            ethBalance,
-            ethNeeded
-        );
     }
 
-    function InvalidERC20AssetDataError(
+    function InvalidERC20AssetDataError(bytes memory assetData) internal pure returns (bytes memory) {
-        bytes memory assetData
+        return abi.encodeWithSelector(bytes4(keccak256("InvalidERC20AssetDataError(bytes)")), assetData);
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("InvalidERC20AssetDataError(bytes)")),
-            assetData
-        );
     }
 
-    function InvalidTakerFeeTokenError(
+    function InvalidTakerFeeTokenError(address token) internal pure returns (bytes memory) {
-        address token
+        return abi.encodeWithSelector(bytes4(keccak256("InvalidTakerFeeTokenError(address)")), token);
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("InvalidTakerFeeTokenError(address)")),
-            token
-        );
     }
 }

contracts/zero-ex/contracts/src/errors/LibWalletRichErrors.sol

@@ -19,9 +19,7 @@
 
 pragma solidity ^0.6.5;
 
-
 library LibWalletRichErrors {
-
     // solhint-disable func-name-mixedcase
 
     function WalletExecuteCallFailedError(
@@ -30,19 +28,16 @@ library LibWalletRichErrors {
         bytes memory callData,
         uint256 callValue,
         bytes memory errorData
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("WalletExecuteCallFailedError(address,address,bytes,uint256,bytes)")),
-    {
+                wallet,
-        return abi.encodeWithSelector(
+                callTarget,
-            bytes4(keccak256("WalletExecuteCallFailedError(address,address,bytes,uint256,bytes)")),
+                callData,
-            wallet,
+                callValue,
-            callTarget,
+                errorData
-            callData,
+            );
-            callValue,
-            errorData
-        );
     }
 
     function WalletExecuteDelegateCallFailedError(
@@ -50,17 +45,14 @@ library LibWalletRichErrors {
         address callTarget,
         bytes memory callData,
         bytes memory errorData
-    )
+    ) internal pure returns (bytes memory) {
-        internal
+        return
-        pure
+            abi.encodeWithSelector(
-        returns (bytes memory)
+                bytes4(keccak256("WalletExecuteDelegateCallFailedError(address,address,bytes,bytes)")),
-    {
+                wallet,
-        return abi.encodeWithSelector(
+                callTarget,
-            bytes4(keccak256("WalletExecuteDelegateCallFailedError(address,address,bytes,bytes)")),
+                callData,
-            wallet,
+                errorData
-            callTarget,
+            );
-            callData,
-            errorData
-        );
     }
 }

contracts/zero-ex/contracts/src/external/FeeCollector.sol

@@ -27,7 +27,7 @@ import "../vendor/v3/IStaking.sol";
 /// @dev The collector contract for protocol fees
 contract FeeCollector is AuthorizableV06 {
     /// @dev Allow ether transfers to the collector.
-    receive() external payable { }
+    receive() external payable {}
 
     constructor() public {
         _addAuthorizedAddress(msg.sender);
@@ -42,22 +42,14 @@ contract FeeCollector is AuthorizableV06 {
         IEtherTokenV06 weth,
         IStaking staking,
         bytes32 poolId
-    )
+    ) external onlyAuthorized {
-        external
-        onlyAuthorized
-    {
         weth.approve(address(staking), type(uint256).max);
         staking.joinStakingPoolAsMaker(poolId);
     }
 
     /// @dev Convert all held ether to WETH. Only an authority can call this.
     /// @param weth The WETH contract.
-    function convertToWeth(
+    function convertToWeth(IEtherTokenV06 weth) external onlyAuthorized {
-        IEtherTokenV06 weth
-    )
-        external
-        onlyAuthorized
-    {
         if (address(this).balance > 0) {
             weth.deposit{value: address(this).balance}();
         }

contracts/zero-ex/contracts/src/external/FeeCollectorController.sol

@@ -25,10 +25,8 @@ import "../vendor/v3/IStaking.sol";
 import "./FeeCollector.sol";
 import "./LibFeeCollector.sol";
 
-
 /// @dev A contract that manages `FeeCollector` contracts.
 contract FeeCollectorController {
-
     /// @dev Hash of the fee collector init code.
     bytes32 public immutable FEE_COLLECTOR_INIT_CODE_HASH;
     /// @dev The WETH contract.
@@ -36,12 +34,7 @@ contract FeeCollectorController {
     /// @dev The staking contract.
     IStaking private immutable STAKING;
 
-    constructor(
+    constructor(IEtherTokenV06 weth, IStaking staking) public {
-        IEtherTokenV06 weth,
-        IStaking staking
-    )
-        public
-    {
         FEE_COLLECTOR_INIT_CODE_HASH = keccak256(type(FeeCollector).creationCode);
         WETH = weth;
         STAKING = staking;
@@ -51,10 +44,7 @@ contract FeeCollectorController {
     ///      and wrap its ETH into WETH. Anyone may call this.
     /// @param poolId The pool ID associated with the staking pool.
     /// @return feeCollector The `FeeCollector` contract instance.
-    function prepareFeeCollectorToPayFees(bytes32 poolId)
+    function prepareFeeCollectorToPayFees(bytes32 poolId) external returns (FeeCollector feeCollector) {
-        external
-        returns (FeeCollector feeCollector)
-    {
         feeCollector = getFeeCollector(poolId);
         uint256 codeSize;
         assembly {
@@ -79,15 +69,8 @@ contract FeeCollectorController {
     ///      has been called once.
     /// @param poolId The pool ID associated with the staking pool.
     /// @return feeCollector The `FeeCollector` contract instance.
-    function getFeeCollector(bytes32 poolId)
+    function getFeeCollector(bytes32 poolId) public view returns (FeeCollector feeCollector) {
-        public
+        return
-        view
+            FeeCollector(LibFeeCollector.getFeeCollectorAddress(address(this), FEE_COLLECTOR_INIT_CODE_HASH, poolId));
-        returns (FeeCollector feeCollector)
-    {
-        return FeeCollector(LibFeeCollector.getFeeCollectorAddress(
-            address(this),
-            FEE_COLLECTOR_INIT_CODE_HASH,
-            poolId
-        ));
     }
 }

contracts/zero-ex/contracts/src/external/FlashWallet.sol

@@ -25,17 +25,15 @@ import "@0x/contracts-utils/contracts/src/v06/errors/LibOwnableRichErrorsV06.sol
 import "../errors/LibWalletRichErrors.sol";
 import "./IFlashWallet.sol";
 
-
 /// @dev A contract that can execute arbitrary calls from its owner.
-contract FlashWallet is
+contract FlashWallet is IFlashWallet {
-    IFlashWallet
-{
     // solhint-disable no-unused-vars,indent,no-empty-blocks
     using LibRichErrorsV06 for bytes;
 
     // solhint-disable
     /// @dev Store the owner/deployer as an immutable to make this contract stateless.
-    address public override immutable owner;
+    address public immutable override owner;
+
     // solhint-enable
 
     constructor() public {
@@ -46,10 +44,7 @@ contract FlashWallet is
     /// @dev Allows only the (immutable) owner to call a function.
     modifier onlyOwner() virtual {
         if (msg.sender != owner) {
-            LibOwnableRichErrorsV06.OnlyOwnerError(
+            LibOwnableRichErrorsV06.OnlyOwnerError(msg.sender, owner).rrevert();
-                msg.sender,
-                owner
-            ).rrevert();
         }
         _;
     }
@@ -63,24 +58,12 @@ contract FlashWallet is
         address payable target,
         bytes calldata callData,
         uint256 value
-    )
+    ) external payable override onlyOwner returns (bytes memory resultData) {
-        external
-        payable
-        override
-        onlyOwner
-        returns (bytes memory resultData)
-    {
         bool success;
         (success, resultData) = target.call{value: value}(callData);
         if (!success) {
             LibWalletRichErrors
-                .WalletExecuteCallFailedError(
+                .WalletExecuteCallFailedError(address(this), target, callData, value, resultData)
-                    address(this),
-                    target,
-                    callData,
-                    value,
-                    resultData
-                )
                 .rrevert();
         }
     }
@@ -90,10 +73,7 @@ contract FlashWallet is
     /// @param target The call target.
     /// @param callData The call data.
     /// @return resultData The data returned by the call.
-    function executeDelegateCall(
+    function executeDelegateCall(address payable target, bytes calldata callData)
-        address payable target,
-        bytes calldata callData
-    )
         external
         payable
         override
@@ -104,32 +84,25 @@ contract FlashWallet is
         (success, resultData) = target.delegatecall(callData);
         if (!success) {
             LibWalletRichErrors
-                .WalletExecuteDelegateCallFailedError(
+                .WalletExecuteDelegateCallFailedError(address(this), target, callData, resultData)
-                    address(this),
-                    target,
-                    callData,
-                    resultData
-                )
                 .rrevert();
         }
     }
 
     // solhint-disable
     /// @dev Allows this contract to receive ether.
-    receive() external override payable {}
+    receive() external payable override {}
+
     // solhint-enable
 
     /// @dev Signal support for receiving ERC1155 tokens.
     /// @param interfaceID The interface ID, as per ERC-165 rules.
     /// @return hasSupport `true` if this contract supports an ERC-165 interface.
-    function supportsInterface(bytes4 interfaceID)
+    function supportsInterface(bytes4 interfaceID) external pure returns (bool hasSupport) {
-        external
+        return
-        pure
+            interfaceID == this.supportsInterface.selector ||
-        returns (bool hasSupport)
+            interfaceID == this.onERC1155Received.selector ^ this.onERC1155BatchReceived.selector ||
-    {
+            interfaceID == this.tokenFallback.selector;
-        return  interfaceID == this.supportsInterface.selector ||
-                interfaceID == this.onERC1155Received.selector ^ this.onERC1155BatchReceived.selector ||
-                interfaceID == this.tokenFallback.selector;
     }
 
     ///  @dev Allow this contract to receive ERC1155 tokens.
@@ -140,11 +113,7 @@ contract FlashWallet is
         uint256, // id,
         uint256, // value,
         bytes calldata //data
-    )
+    ) external pure returns (bytes4 success) {
-        external
-        pure
-        returns (bytes4 success)
-    {
         return this.onERC1155Received.selector;
     }
 
@@ -156,11 +125,7 @@ contract FlashWallet is
         uint256[] calldata, // ids,
         uint256[] calldata, // values,
         bytes calldata // data
-    )
+    ) external pure returns (bytes4 success) {
-        external
-        pure
-        returns (bytes4 success)
-    {
         return this.onERC1155BatchReceived.selector;
     }
 
@@ -169,8 +134,5 @@ contract FlashWallet is
         address, // from,
         uint256, // value,
         bytes calldata // value
-    )
+    ) external pure {}
-        external
-        pure
-    {}
 }

contracts/zero-ex/contracts/src/external/IFlashWallet.sol

@@ -22,10 +22,8 @@ pragma experimental ABIEncoderV2;
 
 import "@0x/contracts-utils/contracts/src/v06/interfaces/IOwnableV06.sol";
 
-
 /// @dev A contract that can execute arbitrary calls from its owner.
 interface IFlashWallet {
-
     /// @dev Execute an arbitrary call. Only an authority can call this.
     /// @param target The call target.
     /// @param callData The call data.
@@ -35,20 +33,14 @@ interface IFlashWallet {
         address payable target,
         bytes calldata callData,
         uint256 value
-    )
+    ) external payable returns (bytes memory resultData);
-        external
-        payable
-        returns (bytes memory resultData);
 
     /// @dev Execute an arbitrary delegatecall, in the context of this puppet.
     ///      Only an authority can call this.
     /// @param target The call target.
     /// @param callData The call data.
     /// @return resultData The data returned by the call.
-    function executeDelegateCall(
+    function executeDelegateCall(address payable target, bytes calldata callData)
-        address payable target,
-        bytes calldata callData
-    )
         external
         payable
         returns (bytes memory resultData);

contracts/zero-ex/contracts/src/external/ILiquidityProviderSandbox.sol

@@ -23,9 +23,7 @@ pragma experimental ABIEncoderV2;
 import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
 import "../vendor/ILiquidityProvider.sol";
 
-
 interface ILiquidityProviderSandbox {
-
     /// @dev Calls `sellTokenForToken` on the given `provider` contract to
     ///      trigger a trade.
     /// @param provider The address of the on-chain liquidity provider.
@@ -41,8 +39,7 @@ interface ILiquidityProviderSandbox {
         address recipient,
         uint256 minBuyAmount,
         bytes calldata auxiliaryData
-    )
+    ) external;
-        external;
 
     /// @dev Calls `sellEthForToken` on the given `provider` contract to
     ///      trigger a trade.
@@ -57,8 +54,7 @@ interface ILiquidityProviderSandbox {
         address recipient,
         uint256 minBuyAmount,
         bytes calldata auxiliaryData
-    )
+    ) external;
-        external;
 
     /// @dev Calls `sellTokenForEth` on the given `provider` contract to
     ///      trigger a trade.
@@ -73,6 +69,5 @@ interface ILiquidityProviderSandbox {
         address recipient,
         uint256 minBuyAmount,
         bytes calldata auxiliaryData
-    )
+    ) external;
-        external;
 }

contracts/zero-ex/contracts/src/external/LibFeeCollector.sol

@@ -20,25 +20,30 @@
 pragma solidity ^0.6.5;
 pragma experimental ABIEncoderV2;
 
-
 /// @dev Helpers for computing `FeeCollector` contract addresses.
 library LibFeeCollector {
-
     /// @dev Compute the CREATE2 address for a fee collector.
     /// @param controller The address of the `FeeCollectorController` contract.
     /// @param initCodeHash The init code hash of the `FeeCollector` contract.
     /// @param poolId The fee collector's pool ID.
-    function getFeeCollectorAddress(address controller, bytes32 initCodeHash, bytes32 poolId)
+    function getFeeCollectorAddress(
-        internal
+        address controller,
-        pure
+        bytes32 initCodeHash,
-        returns (address payable feeCollectorAddress)
+        bytes32 poolId
-    {
+    ) internal pure returns (address payable feeCollectorAddress) {
         // Compute the CREATE2 address for the fee collector.
-        return address(uint256(keccak256(abi.encodePacked(
+        return
-            byte(0xff),
+            address(
-            controller,
+                uint256(
-            poolId, // pool ID is salt
+                    keccak256(
-            initCodeHash
+                        abi.encodePacked(
-        ))));
+                            bytes1(0xff),
+                            controller,
+                            poolId, // pool ID is salt
+                            initCodeHash
+                        )
+                    )
+                )
+            );
     }
 }

contracts/zero-ex/contracts/src/external/LiquidityProviderSandbox.sol

@@ -22,30 +22,22 @@ import "../vendor/ILiquidityProvider.sol";
 import "../vendor/v3/IERC20Bridge.sol";
 import "./ILiquidityProviderSandbox.sol";
 
-
 /// @dev A permissionless contract through which the ZeroEx contract can
 ///      safely trigger a trade on an external `ILiquidityProvider` contract.
-contract LiquidityProviderSandbox is
+contract LiquidityProviderSandbox is ILiquidityProviderSandbox {
-    ILiquidityProviderSandbox
-{
     using LibRichErrorsV06 for bytes;
 
     /// @dev Store the owner as an immutable.
     address public immutable owner;
 
-    constructor(address owner_)
+    constructor(address owner_) public {
-        public
-    {
         owner = owner_;
     }
 
     /// @dev Allows only the (immutable) owner to call a function.
     modifier onlyOwner() virtual {
         if (msg.sender != owner) {
-            LibOwnableRichErrorsV06.OnlyOwnerError(
+            LibOwnableRichErrorsV06.OnlyOwnerError(msg.sender, owner).rrevert();
-                msg.sender,
-                owner
-            ).rrevert();
         }
         _;
     }
@@ -65,18 +57,8 @@ contract LiquidityProviderSandbox is
         address recipient,
         uint256 minBuyAmount,
         bytes calldata auxiliaryData
-    )
+    ) external override onlyOwner {
-        external
+        provider.sellTokenForToken(inputToken, outputToken, recipient, minBuyAmount, auxiliaryData);
-        onlyOwner
-        override
-    {
-        provider.sellTokenForToken(
-            inputToken,
-            outputToken,
-            recipient,
-            minBuyAmount,
-            auxiliaryData
-        );
     }
 
     /// @dev Calls `sellEthForToken` on the given `provider` contract to
@@ -92,17 +74,8 @@ contract LiquidityProviderSandbox is
         address recipient,
         uint256 minBuyAmount,
         bytes calldata auxiliaryData
-    )
+    ) external override onlyOwner {
-        external
+        provider.sellEthForToken(outputToken, recipient, minBuyAmount, auxiliaryData);
-        onlyOwner
-        override
-    {
-        provider.sellEthForToken(
-            outputToken,
-            recipient,
-            minBuyAmount,
-            auxiliaryData
-        );
     }
 
     /// @dev Calls `sellTokenForEth` on the given `provider` contract to
@@ -118,16 +91,7 @@ contract LiquidityProviderSandbox is
         address recipient,
         uint256 minBuyAmount,
         bytes calldata auxiliaryData
-    )
+    ) external override onlyOwner {
-        external
+        provider.sellTokenForEth(inputToken, payable(recipient), minBuyAmount, auxiliaryData);
-        onlyOwner
-        override
-    {
-        provider.sellTokenForEth(
-            inputToken,
-            payable(recipient),
-            minBuyAmount,
-            auxiliaryData
-        );
     }
 }