Publish

- @0x/contracts-erc20@3.3.49
 - @0x/contracts-test-utils@5.4.39
 - @0x/contracts-treasury@1.4.32
 - @0x/contracts-utils@4.8.30
 - @0x/contracts-zero-ex@0.37.9
 - @0x/asset-swapper@16.66.16
 - @0x/contract-addresses@7.1.0
 - @0x/contract-wrappers@13.22.8
 - @0x/protocol-utils@11.16.16

.circleci/config.yml

@@ -1,5 +1,10 @@
 version: 2.1
 
+parameters:
+    cache_version:
+        type: string
+        default: v5
+
 jobs:
     build:
         resource_class: xlarge
@@ -7,10 +12,16 @@ jobs:
             - image: node:16
         environment:
             NODE_OPTIONS: '--max-old-space-size=16384'
-        working_directory: ~/repo
         steps:
             - checkout
+            - run: git submodule update --init --recursive
             - run: echo 'export PATH=$HOME/CIRCLE_PROJECT_REPONAME/node_modules/.bin:$PATH' >> $BASH_ENV
+            - restore_cache:
+                  keys:
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-feat/NerveMixinArbitrum
+            - restore_cache:
+                  keys:
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
             - run:
                   name: install-yarn
                   command: npm install --force --global yarn@1.22.0
@@ -18,65 +29,155 @@ jobs:
                   name: yarn
                   command: yarn --frozen-lockfile --ignore-engines install || yarn --frozen-lockfile --ignore-engines install
             - setup_remote_docker
-            - run: yarn build:ci || yarn build:ci || yarn build:ci || yarn build:ci || yarn build:ci || yarn build:ci
+            - run: yarn build:ci
             - save_cache:
-                  key: repo-{{ .Environment.CIRCLE_SHA1 }}
+                  key: cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
                   paths:
-                      - ~/repo
+                      - ~/project/node_modules
+                      - ~/.cache/yarn
+            - save_cache:
+                  key: lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
+                  paths:
+                      - ~/project/contracts/erc20/generated-artifacts/
+                      - ~/project/contracts/erc20/generated-wrappers/
+                      - ~/project/contracts/erc20/lib/
+                      - ~/project/contracts/erc20/node_modules
+                      - ~/project/contracts/erc20/test/generated-artifacts/
+                      - ~/project/contracts/erc20/test/generated-wrappers/
+                      - ~/project/contracts/test-utils/lib/
+                      - ~/project/contracts/test-utils/node_modules
+                      - ~/project/contracts/treasury/generated-artifacts/
+                      - ~/project/contracts/treasury/generated-wrappers/
+                      - ~/project/contracts/treasury/lib/
+                      - ~/project/contracts/treasury/node_modules
+                      - ~/project/contracts/treasury/test/generated-artifacts/
+                      - ~/project/contracts/treasury/test/generated-wrappers/
+                      - ~/project/contracts/utils/generated-artifacts/
+                      - ~/project/contracts/utils/generated-wrappers/
+                      - ~/project/contracts/utils/lib/
+                      - ~/project/contracts/utils/node_modules
+                      - ~/project/contracts/utils/test/generated-artifacts/
+                      - ~/project/contracts/utils/test/generated-wrappers/
+                      - ~/project/contracts/zero-ex/generated-artifacts/
+                      - ~/project/contracts/zero-ex/generated-wrappers/
+                      - ~/project/contracts/zero-ex/lib/
+                      - ~/project/contracts/zero-ex/node_modules
+                      - ~/project/contracts/zero-ex/test/generated-artifacts/
+                      - ~/project/contracts/zero-ex/test/generated-wrappers/
+                      - ~/project/packages/asset-swapper/node_modules
+                      - ~/project/packages/contract-addresses/lib/
+                      - ~/project/packages/contract-addresses/node_modules
+                      - ~/project/packages/contract-artifacts/lib/
+                      - ~/project/packages/contract-artifacts/node_modules
+                      - ~/project/packages/contract-wrappers/lib/
+                      - ~/project/packages/contract-wrappers/node_modules
+                      - ~/project/packages/protocol-utils/lib/
+                      - ~/project/packages/protocol-utils/node_modules
             - store_artifacts:
                   path: ~/repo/packages/abi-gen/test-cli/output
             - store_artifacts:
                   path: ~/repo/packages/contract-wrappers/generated_docs
     test-exchange-ganache:
-        resource_class: medium+
+        resource_class: xlarge
         docker:
             - image: node:16
-        working_directory: ~/repo
         steps:
+            - checkout
             - restore_cache:
                   keys:
-                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
+            - restore_cache:
+                  keys:
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
             - run: yarn wsrun -p @0x/contracts-exchange -m --serial -c test:circleci
     test-integrations-ganache:
-        resource_class: medium+
+        resource_class: xlarge
         docker:
             - image: node:16
-        working_directory: ~/repo
         steps:
+            - checkout
             - restore_cache:
                   keys:
-                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
+            - restore_cache:
+                  keys:
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
             - run: yarn wsrun -p @0x/contracts-integrations -m --serial -c test:circleci
     test-contracts-staking-ganache:
-        resource_class: medium+
+        resource_class: xlarge
         docker:
             - image: node:16
-        working_directory: ~/repo
         steps:
+            - checkout
             - restore_cache:
                   keys:
-                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
             - run: yarn wsrun -p @0x/contracts-staking -m --serial -c test:circleci
     test-contracts-extra-ganache:
-        resource_class: medium+
+        resource_class: xlarge
         docker:
             - image: node:16
-        working_directory: ~/repo
         steps:
+            - checkout
             - restore_cache:
                   keys:
-                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+                      - cache-{{ checksum "yarn.lock" }}
+            - restore_cache:
+                  keys:
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
             - run: yarn wsrun -p @0x/contracts-exchange-forwarder -p @0x/contracts-coordinator -m --serial -c test:circleci
     test-contracts-rest-ganache:
-        resource_class: medium+
+        resource_class: xlarge
         docker:
             - image: node:16
-        working_directory: ~/repo
         steps:
+            - checkout
+            - run: |
+                  git diff --name-only development >> changed.txt
+                  if ! grep -q \.sol changed.txt; then
+                    circleci-agent step halt
+                  fi
             - restore_cache:
                   keys:
-                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
-            - run: yarn wsrun -p @0x/contracts-multisig -p @0x/contracts-utils -p @0x/contracts-exchange-libs -p  @0x/contracts-erc20 -p @0x/contracts-erc721 -p @0x/contracts-erc1155 -p @0x/contracts-asset-proxy -p @0x/contracts-broker -p @0x/contracts-zero-ex -m --serial -c test:circleci
+            - restore_cache:
+                  keys:
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
+            - run: |
+                  yarn wsrun \
+                    -p @0x/contracts-multisig \
+                    -p @0x/contracts-utils \
+                    -p @0x/contracts-exchange-libs \
+                    -p @0x/contracts-erc20 \
+                    -p @0x/contracts-erc721 \
+                    -p @0x/contracts-erc1155 \
+                    -p @0x/contracts-asset-proxy \
+                    -p @0x/contracts-broker \
+                    -p @0x/contracts-zero-ex \
+                    -m --serial -c test:circleci
+    test-foundry:
+        resource_class: xlarge
+        docker:
+            - image: ghcr.io/foundry-rs/foundry:latest
+        steps:
+            - checkout
+            - run: |
+                  git diff --name-only development >> changed.txt
+                  cat changed.txt
+                  if ! grep -q \.sol changed.txt; then
+                    circleci-agent step halt
+                  fi
+            - restore_cache:
+                  keys:
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
+            - restore_cache:
+                  keys:
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
+            - run: git submodule update --init --recursive
+            - run:
+                  command: forge test
+                  working_directory: ~/project/contracts/zero-ex
     test-publish:
         resource_class: large
         environment:
@@ -84,11 +185,20 @@ jobs:
         docker:
             - image: node:16
             - image: 0xorg/verdaccio
-        working_directory: ~/repo
         steps:
+            - checkout
+            - run: |
+                  git diff --name-only development >> changed.txt
+                  cat changed.txt
+                  if ! grep -q packages/ changed.txt; then
+                    circleci-agent step halt
+                  fi
             - restore_cache:
                   keys:
-                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
+            - restore_cache:
+                  keys:
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
             - run:
                   command: yarn test:publish:circleci
                   no_output_timeout: 1800
@@ -97,71 +207,86 @@ jobs:
     test-doc-generation:
         docker:
             - image: node:16
-        working_directory: ~/repo
         steps:
+            - checkout
             - restore_cache:
                   keys:
-                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
+            - restore_cache:
+                  keys:
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
             - run:
                   command: yarn test:generate_docs:circleci
                   no_output_timeout: 1200
     test-rest:
         docker:
             - image: node:16
-        working_directory: ~/repo
         environment:
             RUST_ROUTER: 'true'
         steps:
+            - checkout
             - restore_cache:
                   keys:
-                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
+            - restore_cache:
+                  keys:
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
             - run: yarn wsrun -p @0x/contracts-test-utils -m --serial -c test:circleci
+            - run: yarn wsrun -p @0x/contract-addresses -m --serial -c test:circleci
             - run: yarn wsrun -p @0x/contract-artifacts -m --serial -c test:circleci
             - run: yarn wsrun -p @0x/contract-wrappers-test -m --serial -c test:circleci
             - run: yarn wsrun -p @0x/order-utils -m --serial -c test:circleci
-            - run: yarn wsrun -p @0x/asset-swapper -m --serial -c test:circleci
             - save_cache:
-                  key: coverage-contract-wrappers-test-{{ .Environment.CIRCLE_SHA1 }}
+                  key: coverage-contract-wrappers-test-{{ checksum "yarn.lock" }}
                   paths:
                       - ~/repo/packages/contract-wrappers-test/coverage/lcov.info
             - save_cache:
-                  key: coverage-order-utils-{{ .Environment.CIRCLE_SHA1 }}
+                  key: coverage-order-utils-{{ checksum "yarn.lock" }}
                   paths:
                       - ~/repo/packages/order-utils/coverage/lcov.info
             - save_cache:
-                  key: coverage-web3-wrapper-{{ .Environment.CIRCLE_SHA1 }}
+                  key: coverage-web3-wrapper-{{ checksum "yarn.lock" }}
                   paths:
                       - ~/repo/packages/web3-wrapper/coverage/lcov.info
     static-tests:
         resource_class: large
-        working_directory: ~/repo
         docker:
             - image: node:16
         steps:
+            - checkout
             - restore_cache:
                   keys:
-                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
-            - run: yarn lerna run lint
+            - restore_cache:
-            - run: yarn prettier:ci
+                  keys:
-            - run: yarn deps_versions:ci
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
-            - run: yarn diff_md_docs:ci
+            - run:
+                  command: yarn lerna run lint
+            - run:
+                  command: yarn prettier:ci
+            - run:
+                  command: yarn deps_versions:ci
+            - run:
+                  command: yarn diff_md_docs:ci
     submit-coverage:
         docker:
             - image: node:16
-        working_directory: ~/repo
         steps:
             - restore_cache:
                   keys:
-                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
             - restore_cache:
                   keys:
-                      - coverage-contract-wrappers-test-{{ .Environment.CIRCLE_SHA1 }}
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
             - restore_cache:
                   keys:
-                      - coverage-order-utils-{{ .Environment.CIRCLE_SHA1 }}
+                      - coverage-contract-wrappers-test-{{ checksum "yarn.lock" }}
             - restore_cache:
                   keys:
-                      - coverage-contracts-{{ .Environment.CIRCLE_SHA1 }}
+                      - coverage-order-utils-{{ checksum "yarn.lock" }}
+            - restore_cache:
+                  keys:
+                      - coverage-contracts-{{ checksum "yarn.lock" }}
             - run: yarn report_coverage
 workflows:
     version: 2
@@ -181,6 +306,9 @@ workflows:
             # - test-contracts-extra-ganache:
             #       requires:
             #           - build
+            - test-foundry:
+                  requires:
+                      - build
             - test-contracts-rest-ganache:
                   requires:
                       - build

.gitignore

@@ -173,6 +173,15 @@ contracts/zero-ex/test/generated-wrappers/
 contracts/treasury/generated-wrappers/
 contracts/treasury/test/generated-wrappers/
 
+# foundry artifacts
+contracts/zero-ex/foundry-artifacts/
+
+# foundry cache 
+contracts/zero-ex/foundry-cache/
+
+# typechain wrappers
+contracts/zero-ex/typechain-wrappers/
+
 # Doc README copy
 packages/*/docs/README.md
 

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "contracts/zero-ex/contracts/deps/forge-std"]
+	path = contracts/zero-ex/contracts/deps/forge-std
+	url = https://github.com/foundry-rs/forge-std

.prettierignore

@@ -80,11 +80,8 @@ lib
 /contracts/erc1155/build/
 /contracts/extensions/build/
 /contracts/exchange-forwarder/build/
-/packages/asset-swapper/generated-artifacts
+/packages/asset-swapper/
-/packages/asset-swapper/generated-wrappers
+/packages/contract-wrappers/src/generated-wrappers/
-/packages/asset-swapper/test/generated-artifacts
-/packages/asset-swapper/test/generated-wrappers
 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
+          }
+        }
+      ]
 }

README.md

@@ -34,7 +34,6 @@ These packages are all under development. See [/contracts/README.md](/contracts/
 
 | Package                                                  | Version                                                                                                                 | Description                                                                                    |
 | -------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
-| [`@0x/asset-swapper`](/packages/asset-swapper)           | [![npm](https://img.shields.io/npm/v/@0x/asset-swapper.svg)](https://www.npmjs.com/package/@0x/asset-swapper)           | Package used to find and create aggregated swaps                                               |
 | [`@0x/protocol-utils`](/packages/protocol-utils)         | [![npm](https://img.shields.io/npm/v/@0x/protocol-utils.svg)](https://www.npmjs.com/package/@0x/protocol-utils)         | A set of utilities for generating, parsing, signing and validating 0x orders                   |
 | [`@0x/contract-addresses`](/packages/contract-addresses) | [![npm](https://img.shields.io/npm/v/@0x/contract-addresses.svg)](https://www.npmjs.com/package/@0x/contract-addresses) | A tiny utility library for getting known deployed contract addresses for a particular network. |
 | [`@0x/contract-wrappers`](/packages/contract-wrappers)   | [![npm](https://img.shields.io/npm/v/@0x/contract-wrappers.svg)](https://www.npmjs.com/package/@0x/contract-wrappers)   | JS/TS wrappers for interacting with the 0x smart contracts                                     |
@@ -82,7 +81,7 @@ yarn build
 To build a specific package:
 
 ```bash
-PKG=@0x/asset-swapper yarn build
+PKG=@0x/protocol-utils yarn build
 ```
 
 To build all contracts packages:
@@ -105,7 +104,7 @@ To watch a specific package and all it's dependent packages:
 PKG=[NPM_PACKAGE_NAME] yarn watch
 
 e.g
-PKG=@0x/asset-swapper yarn watch
+PKG=@0x/protocol-utils yarn watch
 ```
 
 ### Clean
@@ -119,7 +118,7 @@ yarn clean
 Clean a specific package
 
 ```bash
-PKG=@0x/asset-swapper yarn clean
+PKG=@0x/protocol-utils yarn clean
 ```
 
 ### Rebuild
@@ -133,7 +132,7 @@ yarn rebuild
 To re-build (clean & build) a specific package & it's deps:
 
 ```bash
-PKG=@0x/asset-swapper yarn rebuild
+PKG=@0x/protocol-utils yarn rebuild
 ```
 
 ### Lint
@@ -147,7 +146,7 @@ yarn lint
 Lint a specific package:
 
 ```bash
-PKG=@0x/asset-swapper yarn lint
+PKG=@0x/protocol-utils yarn lint
 ```
 
 ### Run Tests
@@ -161,7 +160,7 @@ yarn test
 Run a specific package's test:
 
 ```bash
-PKG=@0x/asset-swapper yarn test
+PKG=@0x/protocol-utils yarn test
 ```
 
 Run all contracts packages tests:

contracts/.solhint.json

@@ -1,22 +0,0 @@
-{
-    "extends": "default",
-    "rules": {
-        "avoid-low-level-calls": false,
-        "avoid-tx-origin": "warn",
-        "bracket-align": false,
-        "code-complexity": false,
-        "compiler-fixed": false,
-        "const-name-snakecase": "error",
-        "expression-indent": "error",
-        "function-max-lines": false,
-        "func-order": "error",
-        "indent": ["error", 4],
-        "max-line-length": ["warn", 160],
-        "no-inline-assembly": false,
-        "quotes": ["error", "double"],
-        "separate-by-one-line-in-contract": "error",
-        "space-after-comma": "error",
-        "statement-indent": "error",
-        "no-empty-blocks": false
-    }
-}

contracts/erc20/.eslintrc

@@ -0,0 +1,25 @@
+{
+  "env": {
+      "es2021": true,
+      "node": true
+  },
+  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended", "prettier"],
+  "overrides": [],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+      "project": "./tsconfig.json",
+      "ecmaVersion": "latest",
+      "sourceType": "module"
+  },
+  "plugins": ["@typescript-eslint"],
+  "ignorePatterns": [
+      "lib/**/*",
+      "contracts/**/*",
+      "generated-wrappers/**/*",
+      "generated-artifacts/**/*",
+      "test/generated-wrappers/**/*",
+      "test/generated-artifacts/**/*"
+
+  ],
+  "rules": {}
+}

contracts/erc20/.solhintignore

@@ -1 +0,0 @@
-contracts/src/ZRXToken.sol

contracts/erc20/CHANGELOG.json

@@ -1,4 +1,149 @@
 [
+    {
+        "timestamp": 1666645023,
+        "version": "3.3.49",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1666381417,
+        "version": "3.3.48",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1665670315,
+        "version": "3.3.47",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1665531940,
+        "version": "3.3.46",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "3.3.45",
+        "changes": [
+            {
+                "note": "Migrate from TSLint to ESLint and fix linting errors",
+                "pr": 589
+            }
+        ],
+        "timestamp": 1665013355
+    },
+    {
+        "timestamp": 1663786955,
+        "version": "3.3.44",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662998180,
+        "version": "3.3.43",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662559804,
+        "version": "3.3.42",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662147076,
+        "version": "3.3.41",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662046042,
+        "version": "3.3.40",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1661462289,
+        "version": "3.3.39",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1661459661,
+        "version": "3.3.38",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1661145612,
+        "version": "3.3.37",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1660093941,
+        "version": "3.3.36",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1660073235,
+        "version": "3.3.35",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1659750766,
+        "version": "3.3.34",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1658950329,
         "version": "3.3.33",

contracts/erc20/CHANGELOG.md

@@ -5,6 +5,70 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v3.3.49 - _October 24, 2022_
+
+    * Dependencies updated
+
+## v3.3.48 - _October 21, 2022_
+
+    * Dependencies updated
+
+## v3.3.47 - _October 13, 2022_
+
+    * Dependencies updated
+
+## v3.3.46 - _October 11, 2022_
+
+    * Dependencies updated
+
+## v3.3.45 - _October 5, 2022_
+
+    * Migrate from TSLint to ESLint and fix linting errors (#589)
+
+## v3.3.44 - _September 21, 2022_
+
+    * Dependencies updated
+
+## v3.3.43 - _September 12, 2022_
+
+    * Dependencies updated
+
+## v3.3.42 - _September 7, 2022_
+
+    * Dependencies updated
+
+## v3.3.41 - _September 2, 2022_
+
+    * Dependencies updated
+
+## v3.3.40 - _September 1, 2022_
+
+    * Dependencies updated
+
+## v3.3.39 - _August 25, 2022_
+
+    * Dependencies updated
+
+## v3.3.38 - _August 25, 2022_
+
+    * Dependencies updated
+
+## v3.3.37 - _August 22, 2022_
+
+    * Dependencies updated
+
+## v3.3.36 - _August 10, 2022_
+
+    * Dependencies updated
+
+## v3.3.35 - _August 9, 2022_
+
+    * Dependencies updated
+
+## v3.3.34 - _August 6, 2022_
+
+    * Dependencies updated
+
 ## v3.3.33 - _July 27, 2022_
 
     * Dependencies updated

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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-erc20",
-    "version": "3.3.33",
+    "version": "3.3.49",
     "engines": {
         "node": ">=6.12"
     },
@@ -23,8 +23,8 @@
         "watch": "sol-compiler -w",
         "clean": "shx rm -rf lib test/generated-artifacts test/generated-wrappers generated-artifacts generated-wrappers",
         "generate_contract_wrappers": "abi-gen --debug --abis  ${npm_package_config_abis} --output test/generated-wrappers --backend ethers",
-        "lint": "tslint --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./test/generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude ./test/generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
+        "lint": "eslint src test",
-        "fix": "tslint --fix --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./test/generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude ./test/generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
+        "fix": "eslint --fix src test",
         "coverage:report:text": "istanbul report text",
         "coverage:report:html": "istanbul report html && open coverage/index.html",
         "profiler:report:html": "istanbul report html && open coverage/index.html",
@@ -32,7 +32,6 @@
         "test:circleci": "yarn test",
         "contracts:gen": "contracts-gen generate",
         "contracts:copy": "contracts-gen copy",
-        "lint-contracts": "solhint -c ../.solhint.json contracts/**/**/**/**/*.sol",
         "docs:md": "ts-doc-gen --sourceDir='$PROJECT_FILES' --output=$MD_FILE_DIR --fileExtension=mdx --tsconfig=./typedoc-tsconfig.json",
         "docs:json": "typedoc --excludePrivate --excludeExternals --excludeProtected --ignoreCompilerErrors --target ES5 --tsconfig typedoc-tsconfig.json --json $JSON_FILE_PATH $PROJECT_FILES"
     },
@@ -51,38 +50,39 @@
     },
     "homepage": "https://github.com/0xProject/protocol/tree/main/contracts/tokens",
     "devDependencies": {
-        "@0x/abi-gen": "^5.8.0",
+        "@0x/abi-gen": "^5.8.1",
-        "@0x/contracts-gen": "^2.0.46",
+        "@0x/contracts-gen": "^2.0.48",
-        "@0x/contracts-test-utils": "^5.4.24",
+        "@0x/contracts-test-utils": "^5.4.39",
-        "@0x/contracts-utils": "^4.8.14",
+        "@0x/contracts-utils": "^4.8.30",
-        "@0x/dev-utils": "^4.2.14",
+        "@0x/dev-utils": "^5.0.0",
-        "@0x/sol-compiler": "^4.8.1",
+        "@0x/sol-compiler": "^4.8.2",
         "@0x/ts-doc-gen": "^0.0.28",
-        "@0x/tslint-config": "^4.1.4",
         "@0x/types": "^3.3.6",
         "@0x/typescript-typings": "^5.3.1",
-        "@0x/utils": "^6.5.3",
+        "@0x/utils": "^7.0.0",
-        "@0x/web3-wrapper": "^7.6.5",
+        "@0x/web3-wrapper": "^8.0.0",
         "@types/lodash": "4.14.104",
         "@types/mocha": "^5.2.7",
         "@types/node": "12.12.54",
+        "@typescript-eslint/eslint-plugin": "^5.38.0",
+        "@typescript-eslint/parser": "^5.38.0",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
-        "ethereum-types": "^3.7.0",
+        "eslint": "^8.23.1",
+        "eslint-config-prettier": "^8.5.0",
+        "ethereum-types": "^3.7.1",
         "lodash": "^4.17.11",
         "make-promises-safe": "^1.1.0",
         "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
-        "solhint": "^1.4.1",
-        "tslint": "5.11.0",
         "typedoc": "~0.16.11",
         "typescript": "4.6.3"
     },
     "dependencies": {
-        "@0x/base-contract": "^6.5.0",
+        "@0x/base-contract": "^7.0.0",
         "ethers": "~4.0.4"
     },
     "publishConfig": {

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/erc20/tslint.json

@@ -1,6 +0,0 @@
-{
-    "extends": ["@0x/tslint-config"],
-    "rules": {
-        "custom-no-magic-numbers": false
-    }
-}

contracts/test-utils/.eslintrc

@@ -0,0 +1,25 @@
+{
+  "env": {
+      "es2021": true,
+      "node": true
+  },
+  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended", "prettier"],
+  "overrides": [],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+      "project": "./tsconfig.json",
+      "ecmaVersion": "latest",
+      "sourceType": "module"
+  },
+  "plugins": ["@typescript-eslint"],
+  "ignorePatterns": [
+      "lib/**/*",
+      "contracts/**/*",
+      "generated-wrappers/**/*",
+      "generated-artifacts/**/*",
+      "test/generated-wrappers/**/*",
+      "test/generated-artifacts/**/*"
+
+  ],
+  "rules": {}
+}

contracts/test-utils/CHANGELOG.json

@@ -1,4 +1,140 @@
 [
+    {
+        "timestamp": 1666645023,
+        "version": "5.4.39",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1666381417,
+        "version": "5.4.38",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1665531940,
+        "version": "5.4.37",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "5.4.36",
+        "changes": [
+            {
+                "note": "Migrate from TSLint to ESLint and fix linting errors",
+                "pr": 589
+            }
+        ],
+        "timestamp": 1665013355
+    },
+    {
+        "timestamp": 1663786955,
+        "version": "5.4.35",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662998180,
+        "version": "5.4.34",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662559804,
+        "version": "5.4.33",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662147076,
+        "version": "5.4.32",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662046042,
+        "version": "5.4.31",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1661462289,
+        "version": "5.4.30",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1661459661,
+        "version": "5.4.29",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1661145612,
+        "version": "5.4.28",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1660093941,
+        "version": "5.4.27",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1660073235,
+        "version": "5.4.26",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1659750766,
+        "version": "5.4.25",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1658950329,
         "version": "5.4.24",

contracts/test-utils/CHANGELOG.md

@@ -5,6 +5,66 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v5.4.39 - _October 24, 2022_
+
+    * Dependencies updated
+
+## v5.4.38 - _October 21, 2022_
+
+    * Dependencies updated
+
+## v5.4.37 - _October 11, 2022_
+
+    * Dependencies updated
+
+## v5.4.36 - _October 5, 2022_
+
+    * Migrate from TSLint to ESLint and fix linting errors (#589)
+
+## v5.4.35 - _September 21, 2022_
+
+    * Dependencies updated
+
+## v5.4.34 - _September 12, 2022_
+
+    * Dependencies updated
+
+## v5.4.33 - _September 7, 2022_
+
+    * Dependencies updated
+
+## v5.4.32 - _September 2, 2022_
+
+    * Dependencies updated
+
+## v5.4.31 - _September 1, 2022_
+
+    * Dependencies updated
+
+## v5.4.30 - _August 25, 2022_
+
+    * Dependencies updated
+
+## v5.4.29 - _August 25, 2022_
+
+    * Dependencies updated
+
+## v5.4.28 - _August 22, 2022_
+
+    * Dependencies updated
+
+## v5.4.27 - _August 10, 2022_
+
+    * Dependencies updated
+
+## v5.4.26 - _August 9, 2022_
+
+    * Dependencies updated
+
+## v5.4.25 - _August 6, 2022_
+
+    * Dependencies updated
+
 ## v5.4.24 - _July 27, 2022_
 
     * Dependencies updated

contracts/test-utils/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-test-utils",
-    "version": "5.4.24",
+    "version": "5.4.39",
     "engines": {
         "node": ">=6.12"
     },
@@ -16,8 +16,8 @@
         "test:coverage": "run-s build run_mocha coverage:report:text coverage:report:lcov",
         "run_mocha": "mocha --require source-map-support/register --require make-promises-safe 'lib/test/**/*.js' --timeout 100000 --bail --exit",
         "clean": "shx rm -rf lib",
-        "lint": "tslint --format stylish --project tsconfig.lint.json",
+        "lint": "eslint src test",
-        "fix": "tslint --fix --format stylish --project tsconfig.lint.json",
+        "fix": "eslint --fix src test",
         "coverage:report:text": "istanbul report text",
         "coverage:report:html": "istanbul report html && open coverage/index.html",
         "profiler:report:html": "istanbul report html && open coverage/index.html",
@@ -34,28 +34,30 @@
     },
     "homepage": "https://github.com/0xProject/protocol/tree/main/contracts/test-utils",
     "devDependencies": {
-        "@0x/sol-compiler": "^4.8.1",
+        "@0x/sol-compiler": "^4.8.2",
-        "@0x/tslint-config": "^4.1.4",
+        "@typescript-eslint/eslint-plugin": "^5.38.0",
+        "@typescript-eslint/parser": "^5.38.0",
+        "eslint": "^8.23.1",
+        "eslint-config-prettier": "^8.5.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
-        "tslint": "5.11.0",
         "typescript": "4.6.3"
     },
     "dependencies": {
-        "@0x/assert": "^3.0.34",
+        "@0x/assert": "^3.0.35",
-        "@0x/base-contract": "^6.5.0",
+        "@0x/base-contract": "^7.0.0",
-        "@0x/contract-addresses": "^6.17.0",
+        "@0x/contract-addresses": "^7.1.0",
-        "@0x/dev-utils": "^4.2.14",
+        "@0x/dev-utils": "^5.0.0",
         "@0x/json-schemas": "^6.4.4",
         "@0x/order-utils": "^10.4.28",
-        "@0x/sol-coverage": "^4.0.45",
+        "@0x/sol-coverage": "^4.0.46",
-        "@0x/sol-profiler": "^4.1.35",
+        "@0x/sol-profiler": "^4.1.36",
-        "@0x/sol-trace": "^3.0.45",
+        "@0x/sol-trace": "^3.0.46",
-        "@0x/subproviders": "^6.6.5",
+        "@0x/subproviders": "^7.0.0",
         "@0x/types": "^3.3.6",
         "@0x/typescript-typings": "^5.3.1",
-        "@0x/utils": "^6.5.3",
+        "@0x/utils": "^7.0.0",
-        "@0x/web3-wrapper": "^7.6.5",
+        "@0x/web3-wrapper": "^8.0.0",
         "@types/bn.js": "^4.11.0",
         "@types/js-combinatorics": "^0.5.29",
         "@types/lodash": "4.14.104",
@@ -67,7 +69,7 @@
         "chai-bignumber": "^3.0.0",
         "decimal.js": "^10.2.0",
         "dirty-chai": "^2.0.1",
-        "ethereum-types": "^3.7.0",
+        "ethereum-types": "^3.7.1",
         "ethereumjs-util": "^7.0.10",
         "ethers": "~4.0.4",
         "js-combinatorics": "^0.5.3",

contracts/test-utils/src/assertions.ts

@@ -38,7 +38,7 @@ async function _getGanacheOrGethErrorAsync(ganacheError: string, gethError: stri
 }
 
 async function _getInsufficientFundsErrorMessageAsync(): Promise<string> {
-    return _getGanacheOrGethErrorAsync("sender doesn't have enough funds", 'insufficient funds');
+    return _getGanacheOrGethErrorAsync('insufficient funds for gas * price + value', 'insufficient funds');
 }
 
 async function _getTransactionFailedErrorMessageAsync(): Promise<string> {
@@ -102,9 +102,9 @@ export async function expectTransactionFailedAsync(p: sendTransactionResult, rea
     if (nodeType === undefined) {
         nodeType = await web3Wrapper.getNodeTypeAsync();
     }
+    const rejectionMessageRegex = new RegExp(`^VM Exception while processing transaction: revert ${reason}$`);
     switch (nodeType) {
         case NodeType.Ganache:
-            const rejectionMessageRegex = new RegExp(`^VM Exception while processing transaction: revert ${reason}$`);
             return expect(p).to.be.rejectedWith(rejectionMessageRegex);
         case NodeType.Geth:
             logUtils.warn(

contracts/test-utils/src/lang_utils.ts

@@ -11,9 +11,14 @@ export function shortZip<T1, T2>(a: T1[], b: T2[]): Array<[T1, T2]> {
 /**
  * Replaces the keys in a deeply nested object. Adapted from https://stackoverflow.com/a/39126851
  */
-export function replaceKeysDeep(obj: {}, mapKeys: (key: string) => string | void): _.Dictionary<{}> {
+export function replaceKeysDeep(
+    obj: Record<string, unknown>,
+    mapKeys: (key: string) => string | void,
+): _.Dictionary<Record<string, unknown>> {
     return _.transform(obj, (result, value, key) => {
         const currentKey = mapKeys(key) || key;
-        result[currentKey] = _.isObject(value) ? replaceKeysDeep(value as {}, mapKeys) : (value as {});
+        result[currentKey] = _.isObject(value)
+            ? replaceKeysDeep(value as Record<string, unknown>, mapKeys)
+            : (value as Record<string, unknown>);
     });
 }

contracts/test-utils/src/mocha_blockchain.ts

@@ -236,7 +236,7 @@ export const describe = _.assign(mochaDescribe, {
  * Like mocha's `describe()`, but sets up a blockchain environment for you.
  */
 export const blockchainTests: BlockchainContextDefinition = _.assign(
-    function(description: string, callback: BlockchainSuiteCallback): ISuite {
+    function (description: string, callback: BlockchainSuiteCallback): ISuite {
         return defineBlockchainSuite(StandardBlockchainTestsEnvironmentSingleton, description, callback, describe);
     },
     {
@@ -275,7 +275,7 @@ export const blockchainTests: BlockchainContextDefinition = _.assign(
             );
         },
         fork: _.assign(
-            function(description: string, callback: BlockchainSuiteCallback): ISuite | void {
+            function (description: string, callback: BlockchainSuiteCallback): ISuite | void {
                 return defineBlockchainSuite(
                     ForkedBlockchainTestsEnvironmentSingleton,
                     description,
@@ -319,7 +319,7 @@ export const blockchainTests: BlockchainContextDefinition = _.assign(
             },
         ),
         live: _.assign(
-            function(description: string, callback: BlockchainSuiteCallback): ISuite | void {
+            function (description: string, callback: BlockchainSuiteCallback): ISuite | void {
                 return defineBlockchainSuite(
                     LiveBlockchainTestsEnvironmentSingleton,
                     description,
@@ -355,7 +355,7 @@ export const blockchainTests: BlockchainContextDefinition = _.assign(
             },
         ),
         resets: _.assign(
-            function(description: string, callback: BlockchainSuiteCallback): ISuite {
+            function (description: string, callback: BlockchainSuiteCallback): ISuite {
                 return defineResetsBlockchainSuite(
                     StandardBlockchainTestsEnvironmentSingleton,
                     description,
@@ -399,7 +399,7 @@ function defineBlockchainSuite<T>(
     callback: BlockchainSuiteCallback,
     describeCall: ContextDefinitionCallback<T>,
 ): T {
-    return describeCall(description, function(this: ISuiteCallbackContext): void {
+    return describeCall(description, function (this: ISuiteCallbackContext): void {
         callback.call(this, envFactory.create());
     });
 }
@@ -410,7 +410,7 @@ function defineResetsBlockchainSuite<T>(
     callback: BlockchainSuiteCallback,
     describeCall: ContextDefinitionCallback<T>,
 ): T {
-    return describeCall(description, function(this: ISuiteCallbackContext): void {
+    return describeCall(description, function (this: ISuiteCallbackContext): void {
         const env = envFactory.create();
         beforeEach(async () => env.blockchainLifecycle.startAsync());
         afterEach(async () => env.blockchainLifecycle.revertAsync());

contracts/test-utils/src/number_utils.ts

@@ -40,10 +40,7 @@ export function getRandomPortion(total: Numberish): BigNumber {
 export function getRandomFloat(min: Numberish, max: Numberish): BigNumber {
     // Generate a really high precision number between [0, 1]
     const r = new BigNumber(crypto.randomBytes(32).toString('hex'), 16).dividedBy(new BigNumber(2).pow(256).minus(1));
-    return new BigNumber(max)
+    return new BigNumber(max).minus(min).times(r).plus(min);
-        .minus(min)
-        .times(r)
-        .plus(min);
 }
 
 export const FIXED_POINT_BASE = new BigNumber(2).pow(127);
@@ -66,7 +63,7 @@ export function fromFixed(n: Numberish): BigNumber {
  * Converts two decimal numbers to integers with `precision` digits, then returns
  * the absolute difference.
  */
-export function getNumericalDivergence(a: Numberish, b: Numberish, precision: number = 18): number {
+export function getNumericalDivergence(a: Numberish, b: Numberish, precision = 18): number {
     const _a = new BigNumber(a);
     const _b = new BigNumber(b);
     const maxIntegerDigits = Math.max(
@@ -77,16 +74,13 @@ export function getNumericalDivergence(a: Numberish, b: Numberish, precision: nu
         const base = 10 ** (precision - maxIntegerDigits);
         return n.times(base).integerValue(BigNumber.ROUND_DOWN);
     };
-    return _toInteger(_a)
+    return _toInteger(_a).minus(_toInteger(_b)).abs().toNumber();
-        .minus(_toInteger(_b))
-        .abs()
-        .toNumber();
 }
 
 /**
  * Asserts that two numbers are equal up to `precision` digits.
  */
-export function assertRoughlyEquals(actual: Numberish, expected: Numberish, precision: number = 18): void {
+export function assertRoughlyEquals(actual: Numberish, expected: Numberish, precision = 18): void {
     if (getNumericalDivergence(actual, expected, precision) <= 1) {
         return;
     }
@@ -96,16 +90,8 @@ export function assertRoughlyEquals(actual: Numberish, expected: Numberish, prec
 /**
  * Asserts that two numbers are equal with up to `maxError` difference between them.
  */
-export function assertIntegerRoughlyEquals(
+export function assertIntegerRoughlyEquals(actual: Numberish, expected: Numberish, maxError = 1, msg?: string): void {
-    actual: Numberish,
+    const diff = new BigNumber(actual).minus(expected).abs().toNumber();
-    expected: Numberish,
-    maxError: number = 1,
-    msg?: string,
-): void {
-    const diff = new BigNumber(actual)
-        .minus(expected)
-        .abs()
-        .toNumber();
     if (diff <= maxError) {
         return;
     }

contracts/test-utils/src/order_utils.ts

@@ -8,10 +8,7 @@ import { BatchMatchOrder, CancelOrder, MatchOrder } from './types';
 
 export const orderUtils = {
     getPartialAmountFloor(numerator: BigNumber, denominator: BigNumber, target: BigNumber): BigNumber {
-        const partialAmount = numerator
+        const partialAmount = numerator.multipliedBy(target).div(denominator).integerValue(BigNumber.ROUND_FLOOR);
-            .multipliedBy(target)
-            .div(denominator)
-            .integerValue(BigNumber.ROUND_FLOOR);
         return partialAmount;
     },
     createFill: (signedOrder: SignedOrder, takerAssetFillAmount?: BigNumber) => {

contracts/test-utils/src/web3_wrapper.ts

@@ -15,7 +15,7 @@ export const txDefaults = {
     gasPrice: constants.DEFAULT_GAS_PRICE,
 };
 
-export let providerConfigs: Web3Config = {
+export const providerConfigs: Web3Config = {
     total_accounts: constants.NUM_TEST_ACCOUNTS,
     shouldUseInProcessGanache: true,
     shouldAllowUnlimitedContractSize: true,

contracts/test-utils/test/mocha_blockchain.ts

@@ -4,6 +4,7 @@ import * as process from 'process';
 import { expect } from '../src/chai_setup';
 import { constants } from '../src/constants';
 import { blockchainTests, describe } from '../src/mocha_blockchain';
+import { append } from './subtests/mocha_blockchain_1';
 
 blockchainTests('mocha blockchain extensions', env => {
     describe('blockchainTests()', () => {
@@ -78,7 +79,7 @@ blockchainTests('mocha blockchain extensions', env => {
         });
 
         describe('subtests', () => {
-            require('./subtests/mocha_blockchain_1').append(env);
+            append(env);
         });
     });
 
@@ -96,7 +97,7 @@ blockchainTests('mocha blockchain extensions', env => {
 function createHookedObject(obj: any, handler: (name: string) => void, methods: string[]): any {
     const hookedMethods = _.map(methods, methodName => {
         // tslint:disable: only-arrow-functions
-        return function(this: any, ...args: any[]): any {
+        return function (this: any, ...args: any[]): any {
             handler(methodName);
             return obj[methodName].call(this, ...args);
         };

contracts/test-utils/test/order_hash_test.ts

@@ -55,7 +55,7 @@ describe('Order hashing', () => {
         it('throws a readable error message if taker format is invalid', async () => {
             const orderWithInvalidtakerFormat = {
                 ...order,
-                takerAddress: (null as any) as string,
+                takerAddress: null as any as string,
             };
             const expectedErrorMessage = `Expected order to conform to schema`;
             expect(() => orderHashUtils.getOrderHashHex(orderWithInvalidtakerFormat)).to.throw(expectedErrorMessage);

contracts/test-utils/tslint.json

@@ -1,6 +0,0 @@
-{
-    "extends": ["@0x/tslint-config"],
-    "rules": {
-        "custom-no-magic-numbers": false
-    }
-}

contracts/treasury/.eslintrc

@@ -0,0 +1,25 @@
+{
+  "env": {
+      "es2021": true,
+      "node": true
+  },
+  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended", "prettier"],
+  "overrides": [],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+      "project": "./tsconfig.json",
+      "ecmaVersion": "latest",
+      "sourceType": "module"
+  },
+  "plugins": ["@typescript-eslint"],
+  "ignorePatterns": [
+      "lib/**/*",
+      "contracts/**/*",
+      "generated-wrappers/**/*",
+      "generated-artifacts/**/*",
+      "test/generated-wrappers/**/*",
+      "test/generated-artifacts/**/*"
+
+  ],
+  "rules": {}
+}

contracts/treasury/CHANGELOG.json

@@ -1,4 +1,149 @@
 [
+    {
+        "timestamp": 1666645023,
+        "version": "1.4.32",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1666381417,
+        "version": "1.4.31",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1665670315,
+        "version": "1.4.30",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1665531940,
+        "version": "1.4.29",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "1.4.28",
+        "changes": [
+            {
+                "note": "Migrate from TSLint to ESLint and fix linting errors",
+                "pr": 589
+            }
+        ],
+        "timestamp": 1665013355
+    },
+    {
+        "timestamp": 1663786955,
+        "version": "1.4.27",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662998180,
+        "version": "1.4.26",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662559804,
+        "version": "1.4.25",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662147076,
+        "version": "1.4.24",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662046042,
+        "version": "1.4.23",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1661462289,
+        "version": "1.4.22",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1661459661,
+        "version": "1.4.21",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1661145612,
+        "version": "1.4.20",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1660093941,
+        "version": "1.4.19",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1660073235,
+        "version": "1.4.18",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1659750766,
+        "version": "1.4.17",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1658950329,
         "version": "1.4.16",

contracts/treasury/CHANGELOG.md

@@ -5,6 +5,70 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v1.4.32 - _October 24, 2022_
+
+    * Dependencies updated
+
+## v1.4.31 - _October 21, 2022_
+
+    * Dependencies updated
+
+## v1.4.30 - _October 13, 2022_
+
+    * Dependencies updated
+
+## v1.4.29 - _October 11, 2022_
+
+    * Dependencies updated
+
+## v1.4.28 - _October 5, 2022_
+
+    * Migrate from TSLint to ESLint and fix linting errors (#589)
+
+## v1.4.27 - _September 21, 2022_
+
+    * Dependencies updated
+
+## v1.4.26 - _September 12, 2022_
+
+    * Dependencies updated
+
+## v1.4.25 - _September 7, 2022_
+
+    * Dependencies updated
+
+## v1.4.24 - _September 2, 2022_
+
+    * Dependencies updated
+
+## v1.4.23 - _September 1, 2022_
+
+    * Dependencies updated
+
+## v1.4.22 - _August 25, 2022_
+
+    * Dependencies updated
+
+## v1.4.21 - _August 25, 2022_
+
+    * Dependencies updated
+
+## v1.4.20 - _August 22, 2022_
+
+    * Dependencies updated
+
+## v1.4.19 - _August 10, 2022_
+
+    * Dependencies updated
+
+## v1.4.18 - _August 9, 2022_
+
+    * Dependencies updated
+
+## v1.4.17 - _August 6, 2022_
+
+    * Dependencies updated
+
 ## v1.4.16 - _July 27, 2022_
 
     * Dependencies updated

contracts/treasury/contracts/external/ISablier.sol

@@ -50,11 +50,15 @@ 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);
 
     function cancelStream(uint256 streamId) 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/treasury/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-treasury",
-    "version": "1.4.16",
+    "version": "1.4.32",
     "engines": {
         "node": ">=6.12"
     },
@@ -21,12 +21,11 @@
         "watch": "sol-compiler -w",
         "clean": "shx rm -rf lib test/generated-artifacts test/generated-wrappers generated-artifacts generated-wrappers",
         "generate_contract_wrappers": "abi-gen --debug --abis  ${npm_package_config_abis} --output test/generated-wrappers --backend ethers",
-        "lint": "tslint --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./test/generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude ./test/generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
+        "lint": "eslint src test",
-        "fix": "tslint --fix --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude ./test/generated-wrappers/**/* --exclude ./test/generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
+        "fix": "eslint --fix src test",
         "test:circleci": "yarn test",
         "contracts:gen": "contracts-gen generate",
         "contracts:copy": "contracts-gen copy",
-        "lint-contracts": "#solhint -c ../.solhint.json contracts/**/**/**/**/*.sol",
         "docs:md": "ts-doc-gen --sourceDir='$PROJECT_FILES' --output=$MD_FILE_DIR --fileExtension=mdx --tsconfig=./typedoc-tsconfig.json",
         "docs:json": "typedoc --excludePrivate --excludeExternals --excludeProtected --ignoreCompilerErrors --target ES5 --tsconfig typedoc-tsconfig.json --json $JSON_FILE_PATH $PROJECT_FILES",
         "publish:private": "yarn build && gitpkg publish"
@@ -46,40 +45,41 @@
     },
     "homepage": "https://github.com/0xProject/protocol/tree/main/contracts/treasury",
     "devDependencies": {
-        "@0x/abi-gen": "^5.8.0",
+        "@0x/abi-gen": "^5.8.1",
-        "@0x/contract-addresses": "^6.17.0",
+        "@0x/contract-addresses": "^7.1.0",
         "@0x/contracts-asset-proxy": "^3.7.19",
-        "@0x/contracts-erc20": "^3.3.33",
+        "@0x/contracts-erc20": "^3.3.49",
-        "@0x/contracts-gen": "^2.0.46",
+        "@0x/contracts-gen": "^2.0.48",
         "@0x/contracts-staking": "^2.0.45",
-        "@0x/contracts-test-utils": "^5.4.24",
+        "@0x/contracts-test-utils": "^5.4.39",
-        "@0x/sol-compiler": "^4.8.1",
+        "@0x/sol-compiler": "^4.8.2",
         "@0x/ts-doc-gen": "^0.0.28",
-        "@0x/tslint-config": "^4.1.4",
         "@types/isomorphic-fetch": "^0.0.35",
         "@types/lodash": "4.14.104",
         "@types/mocha": "^5.2.7",
         "@types/prompts": "^2.0.9",
+        "@typescript-eslint/eslint-plugin": "^5.38.0",
+        "@typescript-eslint/parser": "^5.38.0",
+        "eslint": "^8.23.1",
+        "eslint-config-prettier": "^8.5.0",
         "isomorphic-fetch": "^3.0.0",
         "lodash": "^4.17.11",
         "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "prompts": "^2.4.0",
         "shx": "^0.2.2",
-        "solhint": "^1.4.1",
-        "tslint": "5.11.0",
         "typedoc": "~0.16.11",
         "typescript": "4.6.3"
     },
     "dependencies": {
-        "@0x/base-contract": "^6.5.0",
+        "@0x/base-contract": "^7.0.0",
-        "@0x/protocol-utils": "^11.16.0",
+        "@0x/protocol-utils": "^11.16.16",
-        "@0x/subproviders": "^6.6.5",
+        "@0x/subproviders": "^7.0.0",
         "@0x/types": "^3.3.6",
         "@0x/typescript-typings": "^5.3.1",
-        "@0x/utils": "^6.5.3",
+        "@0x/utils": "^7.0.0",
-        "@0x/web3-wrapper": "^7.6.5",
+        "@0x/web3-wrapper": "^8.0.0",
-        "ethereum-types": "^3.7.0",
+        "ethereum-types": "^3.7.1",
         "ethereumjs-util": "^7.0.10"
     },
     "publishConfig": {

contracts/treasury/tslint.json

@@ -1,13 +0,0 @@
-{
-    "extends": ["@0x/tslint-config"],
-    "rules": {
-        "custom-no-magic-numbers": false,
-        "max-file-line-count": false,
-        "no-non-null-assertion": false,
-        "no-unnecessary-type-assertion": false,
-        "number-literal-format": false
-    },
-    "linterOptions": {
-        "exclude": ["src/artifacts.ts", "test/artifacts.ts"]
-    }
-}

contracts/utils/.eslintrc

@@ -0,0 +1,25 @@
+{
+  "env": {
+      "es2021": true,
+      "node": true
+  },
+  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended", "prettier"],
+  "overrides": [],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+      "project": "./tsconfig.json",
+      "ecmaVersion": "latest",
+      "sourceType": "module"
+  },
+  "plugins": ["@typescript-eslint"],
+  "ignorePatterns": [
+      "lib/**/*",
+      "contracts/**/*",
+      "generated-wrappers/**/*",
+      "generated-artifacts/**/*",
+      "test/generated-wrappers/**/*",
+      "test/generated-artifacts/**/*"
+
+  ],
+  "rules": {}
+}

contracts/utils/CHANGELOG.json

@@ -1,4 +1,149 @@
 [
+    {
+        "timestamp": 1666645023,
+        "version": "4.8.30",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1666381417,
+        "version": "4.8.29",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1665670315,
+        "version": "4.8.28",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1665531940,
+        "version": "4.8.27",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "4.8.26",
+        "changes": [
+            {
+                "note": "Migrate from TSLint to ESLint and fix linting errors",
+                "pr": 589
+            }
+        ],
+        "timestamp": 1665013355
+    },
+    {
+        "timestamp": 1663786955,
+        "version": "4.8.25",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662998180,
+        "version": "4.8.24",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662559804,
+        "version": "4.8.23",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662147076,
+        "version": "4.8.22",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1662046042,
+        "version": "4.8.21",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1661462289,
+        "version": "4.8.20",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1661459661,
+        "version": "4.8.19",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1661145612,
+        "version": "4.8.18",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1660093941,
+        "version": "4.8.17",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1660073235,
+        "version": "4.8.16",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1659750766,
+        "version": "4.8.15",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1658950329,
         "version": "4.8.14",

contracts/utils/CHANGELOG.md

@@ -5,6 +5,70 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v4.8.30 - _October 24, 2022_
+
+    * Dependencies updated
+
+## v4.8.29 - _October 21, 2022_
+
+    * Dependencies updated
+
+## v4.8.28 - _October 13, 2022_
+
+    * Dependencies updated
+
+## v4.8.27 - _October 11, 2022_
+
+    * Dependencies updated
+
+## v4.8.26 - _October 5, 2022_
+
+    * Migrate from TSLint to ESLint and fix linting errors (#589)
+
+## v4.8.25 - _September 21, 2022_
+
+    * Dependencies updated
+
+## v4.8.24 - _September 12, 2022_
+
+    * Dependencies updated
+
+## v4.8.23 - _September 7, 2022_
+
+    * Dependencies updated
+
+## v4.8.22 - _September 2, 2022_
+
+    * Dependencies updated
+
+## v4.8.21 - _September 1, 2022_
+
+    * Dependencies updated
+
+## v4.8.20 - _August 25, 2022_
+
+    * Dependencies updated
+
+## v4.8.19 - _August 25, 2022_
+
+    * Dependencies updated
+
+## v4.8.18 - _August 22, 2022_
+
+    * Dependencies updated
+
+## v4.8.17 - _August 10, 2022_
+
+    * Dependencies updated
+
+## v4.8.16 - _August 9, 2022_
+
+    * Dependencies updated
+
+## v4.8.15 - _August 6, 2022_
+
+    * Dependencies updated
+
 ## v4.8.14 - _July 27, 2022_
 
     * Dependencies updated

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);
     }
-
 }