remove old code from multiplex foundry tests

install deps and test and add the --root option

.circleci/config.yml

@@ -0,0 +1,372 @@
+version: 2.1
+
+parameters:
+    cache_version:
+        type: string
+        default: v5
+
+jobs:
+    build:
+        resource_class: xlarge
+        docker:
+            - image: node:16
+        environment:
+            NODE_OPTIONS: '--max-old-space-size=16384'
+        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
+            - run:
+                  name: yarn
+                  command: yarn --frozen-lockfile --ignore-engines install || yarn --frozen-lockfile --ignore-engines install
+            - setup_remote_docker
+            - run: yarn build:ci
+            - save_cache:
+                  key: cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
+                  paths:
+                      - ~/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: xlarge
+        docker:
+            - image: node:16
+        steps:
+            - checkout
+            - restore_cache:
+                  keys:
+                      - 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: xlarge
+        docker:
+            - image: node:16
+        steps:
+            - checkout
+            - restore_cache:
+                  keys:
+                      - 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: xlarge
+        docker:
+            - image: node:16
+        steps:
+            - checkout
+            - restore_cache:
+                  keys:
+                      - 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: xlarge
+        docker:
+            - image: node:16
+        steps:
+            - checkout
+            - restore_cache:
+                  keys:
+                      - 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: xlarge
+        docker:
+            - image: node:16
+        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:
+                      - 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-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-local:
+        resource_class: xlarge
+        docker:
+            # Using nightly as foundry:latest is ~2 months old
+            # which seems to cause an issue with latest forge-std
+            # https://github.com/foundry-rs/forge-std/issues/230
+            - image: ghcr.io/foundry-rs/foundry:nightly
+        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:
+                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+            - run:
+                command: git submodule update --init --recursive
+            - run:
+                command: FOUNDRY_PROFILE=local && forge test
+                working_directory: ~/project/contracts/zero-ex
+    test-foundry-forked:
+        resource_class: xlarge
+        docker:
+            # Using nightly as foundry:latest is ~2 months old
+            # which seems to cause an issue with latest forge-std
+            # https://github.com/foundry-rs/forge-std/issues/230
+            - image: ghcr.io/foundry-rs/foundry:nightly
+        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:
+                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+            - run:
+                command: git submodule update --init --recursive
+            - run:
+                command: FOUNDRY_PROFILE=forked && forge test
+                working_directory: ~/project/contracts/zero-ex
+    test-publish:
+        resource_class: large
+        environment:
+            NODE_OPTIONS: '--max-old-space-size=6442'
+        docker:
+            - image: node:16
+            - image: 0xorg/verdaccio
+        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:
+                      - 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
+            - store_artifacts:
+                  path: ~/.npm/_logs
+    test-doc-generation:
+        docker:
+            - image: node:16
+        steps:
+            - checkout
+            - restore_cache:
+                  keys:
+                      - 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
+        environment:
+            RUST_ROUTER: 'true'
+        steps:
+            - checkout
+            - restore_cache:
+                  keys:
+                      - 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
+            - save_cache:
+                  key: coverage-contract-wrappers-test-{{ checksum "yarn.lock" }}
+                  paths:
+                      - ~/repo/packages/contract-wrappers-test/coverage/lcov.info
+            - save_cache:
+                  key: coverage-order-utils-{{ checksum "yarn.lock" }}
+                  paths:
+                      - ~/repo/packages/order-utils/coverage/lcov.info
+            - save_cache:
+                  key: coverage-web3-wrapper-{{ checksum "yarn.lock" }}
+                  paths:
+                      - ~/repo/packages/web3-wrapper/coverage/lcov.info
+    static-tests:
+        resource_class: large
+        docker:
+            - image: node:16
+        steps:
+            - checkout
+            - restore_cache:
+                  keys:
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
+            - restore_cache:
+                  keys:
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
+            - run:
+                  command: yarn lerna run lint
+            - run:
+                  command: yarn prettier:ci
+            - run:
+                  command: yarn deps_versions:ci
+            - run:
+                  command: yarn diff_md_docs:ci
+            - run:
+                  command: yarn test:links
+    submit-coverage:
+        docker:
+            - image: node:16
+        steps:
+            - restore_cache:
+                  keys:
+                      - cache-{{ checksum "yarn.lock" }}-<< pipeline.parameters.cache_version >>
+            - restore_cache:
+                  keys:
+                      - lib-{{ .Environment.CIRCLE_SHA1 }}-<< pipeline.parameters.cache_version >>
+            - restore_cache:
+                  keys:
+                      - coverage-contract-wrappers-test-{{ checksum "yarn.lock" }}
+            - restore_cache:
+                  keys:
+                      - coverage-order-utils-{{ checksum "yarn.lock" }}
+            - restore_cache:
+                  keys:
+                      - coverage-contracts-{{ checksum "yarn.lock" }}
+            - run: yarn report_coverage
+workflows:
+    version: 2
+    main:
+        jobs:
+            - build
+            # Disabled until we begin actively developing on these packages again.
+            # - test-exchange-ganache:
+            #       requires:
+            #           - build
+            # - test-integrations-ganache:
+            #       requires:
+            #           - build
+            # - test-contracts-staking-ganache:
+            #       requires:
+            #           - build
+            # - test-contracts-extra-ganache:
+            #       requires:
+            #           - build
+            - test-foundry-local:
+                  requires:
+                      - build
+            - test-foundry-forked:
+                  requires:
+                      - build
+            - test-contracts-rest-ganache:
+                  requires:
+                      - build
+            - test-rest:
+                  requires:
+                      - build
+            - static-tests:
+                  requires:
+                      - build
+            - test-publish:
+                  requires:
+                      - build
+            - test-doc-generation:
+                  requires:
+                      - build
+            # Disabled until this repo has a coveralls API key
+            # - submit-coverage:
+            #       requires:
+            #           # Disabled until we begin actively developing on these packages again.
+            #           # - test-exchange-ganache
+            #           # - test-integrations-ganache
+            #           # - test-contracts-staking-ganache
+            #           # - test-contracts-extra-ganache
+            #           - test-contracts-rest-ganache
+            #           - test-rest
+            #           - static-tests

.github/autolabeler.yml

@@ -1,2 +1,6 @@
-documentation: ['docs']
-liquidity integrations: ['contracts/zero-ex/contracts/src/transformers']
+python: ['python-packages']
+contracts: ['contracts']
+@0x/contract-addresses: ['packages/contract-addresses']
+@0x/order-utils: ['packages/order-utils']
+@0x/contract-artifacts: ['packages/contract-artifacts']
+@0x/contract-wrappers: ['packages/contract-wrappers']

.github/dependabot.yml

@@ -1,7 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: github-actions
-    directory: /
-    schedule:
-      interval: monthly
-    target-branch: "development"

.github/stale.yml

@@ -0,0 +1,19 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 30
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 30
+# Issues with these labels will never be considered stale
+exemptLabels:
+    - pinned
+    - security
+# Label to use when marking an issue as stale
+staleLabel: stale
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+    This issue has been automatically marked as stale because it has not had
+    recent activity. It will be closed if no further activity occurs. Thank you
+    for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: >
+    This issue has been automatically closed because no activity occured in 7 days after being marked as stale. If it's still relevant - feel free to reopen. Thank you
+    for your contributions.

.github/workflows/ci.yml

@@ -1,137 +0,0 @@
-name: Continuous Integration
-on:
-    push:
-        branches:
-            - main
-            - development
-    pull_request:
-
-jobs:
-    build:
-        name: Build and test
-        runs-on: ubuntu-latest
-        env:
-            ARBITRUM_RPC_URL: ${{ secrets.ARBITRUM_RPC_URL }}
-            AVALANCHE_RPC_URL: ${{ secrets.AVALANCHE_RPC_URL }}
-            BSC_RPC_URL: ${{ secrets.BSC_RPC_URL }}
-            FANTOM_RPC_URL: ${{ secrets.FANTOM_RPC_URL }}
-            MAINNET_RPC_URL: ${{ secrets.MAINNET_RPC_URL }}
-            OPTIMISM_RPC_URL: ${{ secrets.OPTIMISM_RPC_URL }}
-            POLYGON_RPC_URL: ${{ secrets.POLYGON_RPC_URL }}
-        steps:
-            - uses: actions/checkout@v3
-              with:
-                  submodules: recursive
-
-            - name: Setup Node
-              uses: actions/setup-node@v3
-              with:
-                  node-version: '16'
-
-            - name: Install dependencies
-              run: yarn install --frozen-lockfile
-
-            - name: Build solution
-              run: yarn build
-
-            - name: Lint typescript
-              run: yarn lint:ts
-
-            - name: Lint solidity
-              run: yarn lint:contracts
-
-            - name: Run prettier
-              run: yarn prettier:ci
-
-            - name: Check dependent packages have consistent versions
-              run: yarn deps_versions:ci
-
-            - name: Check diff in docs
-              run: yarn diff_md_docs:ci
-
-            - name: Check for broken links in markdown files
-              run: yarn test:links
-
-            - name: Test doc generation
-              run: yarn test:generate_docs:ci
-
-            - name: Test @0x/contracts-*
-              run: |
-                  yarn wsrun \
-                    -p @0x/contracts-multisig \
-                    -p @0x/contracts-utils \
-                    -p @0x/contracts-exchange-libs \
-                    -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:ci
-
-            - name: Test local @0x/contracts-*
-              run: |
-                  yarn wsrun \
-                    -p @0x/contracts-test-utils \
-                    -p @0x/contract-addresses \
-                    -p @0x/contract-artifacts \
-                    -p @0x/contract-wrappers-test \
-                    -p @0x/order-utils \
-                    -m --serial -c test:ci
-
-            - name: Add foundry
-              uses: foundry-rs/foundry-toolchain@v1
-              with:
-                  version: nightly
-
-            - name: Run Forge build for erc20
-              working-directory: contracts/erc20
-              run: |
-                  forge --version
-                  forge build --sizes
-
-            - name: Run Forge tests for erc20
-              working-directory: contracts/erc20
-              run: |
-                  forge test -vvv --gas-report
-
-            - name: Run Forge coverage for erc20
-              working-directory: contracts/erc20
-              run: |
-                  forge coverage --report summary --report lcov
-
-            - name: Upload the coverage report to Coveralls
-              uses: coverallsapp/github-action@master
-              with:
-                  github-token: ${{ secrets.GITHUB_TOKEN }}
-                  base-path: ./contracts/erc20/
-                  path-to-lcov: ./contracts/erc20/lcov.info
-
-            - name: Run Forge build for zero-ex
-              working-directory: contracts/zero-ex
-              run: |
-                  forge --version
-                  forge build --sizes
-
-            - name: Run Forge tests for zero-ex
-              working-directory: contracts/zero-ex
-              run: |
-                  forge test -vvv --gas-report
-
-            - name: Run Forge coverage for zero-ex
-              working-directory: contracts/zero-ex
-              run: |
-                  forge coverage --report summary --report lcov
-
-            - name: Upload the coverage report to Coveralls
-              uses: coverallsapp/github-action@master
-              with:
-                  github-token: ${{ secrets.GITHUB_TOKEN }}
-                  base-path: ./contracts/zero-ex/
-                  path-to-lcov: ./contracts/zero-ex/lcov.info
-
-            - name: Check coverage threshold
-              uses: VeryGoodOpenSource/very_good_coverage@v2
-              with:
-                  path: ./contracts/zero-ex/lcov.info
-                  min_coverage: 6.98
-                  exclude: '**/tests'

.github/workflows/stale.yml

@@ -1,40 +0,0 @@
-name: "Close stale issues and PRs"
-on:
-  schedule:
-    - cron: "0 8 * * 1-5" # This is in UTC.
-  # Do a dry-run (debug-only: true) whenever this workflow itself is changed.
-  pull_request:
-    paths:
-      - .github/workflows/stale.yml
-    types:
-      - opened
-      - synchronize
-
-permissions:
-  issues: write
-  pull-requests: write
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/stale@v7
-        with:
-          ascending: true # Spend API operations budget on older, more-likely-to-get-closed issues first
-          close-issue-message: "" # Leave no comment when closing
-          close-pr-message: "" # Leave no comment when closing
-          days-before-issue-stale: 30
-          days-before-pr-stale: 30
-          days-before-close: 14
-          debug-only: ${{ github.event_name == 'pull_request' }} # Dry-run when true.
-          exempt-issue-labels: bug,enhancement,feature,question
-          # No actual changes get made in debug-only mode, so we can raise the operations ceiling.
-          operations-per-run: ${{ github.event_name == 'pull_request' && 100 || 30}}
-          stale-issue-label: stale
-          stale-issue-message: "This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions."
-          stale-pr-label: stale
-          stale-pr-message: "This pull request has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions."
-          # Time immemorial when in debug-only mode (ie. on pull requests).
-          # `STALEBOT_START_DATE` otherwise.
-          # You can use this as a killswitch by setting `STALEBOT_START_DATE` in the far future.
-          start-date: ${{ github.event_name == 'pull_request' && '1970-01-01T00:00:00Z' || secrets.STALEBOT_START_DATE }} # ISO 8601 or RFC 2822

.gitignore

@@ -15,6 +15,9 @@ pids
 *.db
 *.sqlite
 
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
 # Coverage directory used by tools like istanbul
 coverage
 
@@ -77,22 +80,104 @@ TODO.md
 .idea
 
 # generated contract artifacts/
-generated-artifacts/
+contracts/broker/generated-artifacts/
+contracts/broker/test/generated-artifacts/
+contracts/erc20-bridge-sampler/generated-artifacts/
+contracts/erc20-bridge-sampler/test/generated-artifacts/
+contracts/integrations/generated-artifacts/
+contracts/integrations/test/generated-artifacts/
+contracts/staking/generated-artifacts/
+contracts/staking/test/generated-artifacts/
+contracts/coordinator/generated-artifacts/
+contracts/coordinator/test/generated-artifacts/
+contracts/exchange/generated-artifacts/
+contracts/exchange/test/generated-artifacts/
+contracts/asset-proxy/generated-artifacts/
+contracts/asset-proxy/test/generated-artifacts/
+contracts/multisig/generated-artifacts/
+contracts/multisig/test/generated-artifacts/
+contracts/utils/generated-artifacts/
+contracts/utils/test/generated-artifacts/
+contracts/exchange-libs/generated-artifacts/
+contracts/exchange-libs/test/generated-artifacts/
+contracts/erc20/generated-artifacts/
+contracts/erc20/test/generated-artifacts/
+contracts/erc721/generated-artifacts/
+contracts/erc721/test/generated-artifacts/
+contracts/erc1155/generated-artifacts/
+contracts/erc1155/test/generated-artifacts/
+contracts/extensions/generated-artifacts/
+contracts/extensions/test/generated-artifacts/
+contracts/exchange-forwarder/generated-artifacts/
+contracts/exchange-forwarder/test/generated-artifacts/
+contracts/dev-utils/generated-artifacts/
+contracts/dev-utils/test/generated-artifacts/
+contracts/zero-ex/generated-artifacts/
+contracts/zero-ex/test/generated-artifacts/
+contracts/treasury/generated-artifacts/
+contracts/treasury/test/generated-artifacts/
+
+# generated truffle contract artifacts/
+contracts/broker/build/
+contracts/erc20-bridge-sampler/build/
+contracts/staking/build/
+contracts/coordinator/build/
+contracts/exchange/build/
+contracts/asset-proxy/build/
+contracts/multisig/build/
+contracts/utils/build/
+contracts/exchange-libs/build/
+contracts/erc20/build/
+contracts/erc721/build/
+contracts/erc1155/build/
+contracts/extensions/build/
+contracts/exchange-forwarder/build/
+contracts/dev-utils/build/
 
 # generated contract wrappers
-generated-wrappers/
-
-# forge std-lib
-contracts/zero-ex/contracts/deps/forge-std
+contracts/broker/generated-wrappers/
+contracts/broker/test/generated-wrappers/
+packages/python-contract-wrappers/generated/
+contracts/erc20-bridge-sampler/generated-wrappers/
+contracts/erc20-bridge-sampler/test/generated-wrappers/
+contracts/integrations/generated-wrappers/
+contracts/integrations/test/generated-wrappers/
+contracts/staking/generated-wrappers/
+contracts/staking/test/generated-wrappers/
+contracts/coordinator/generated-wrappers/
+contracts/coordinator/test/generated-wrappers/
+contracts/exchange/generated-wrappers/
+contracts/exchange/test/generated-wrappers/
+contracts/asset-proxy/generated-wrappers/
+contracts/asset-proxy/test/generated-wrappers/
+contracts/multisig/generated-wrappers/
+contracts/multisig/test/generated-wrappers/
+contracts/utils/generated-wrappers/
+contracts/utils/test/generated-wrappers/
+contracts/exchange-libs/generated-wrappers/
+contracts/exchange-libs/test/generated-wrappers/
+contracts/erc20/generated-wrappers/
+contracts/erc20/test/generated-wrappers/
+contracts/erc721/generated-wrappers/
+contracts/erc721/test/generated-wrappers/
+contracts/erc1155/generated-wrappers/
+contracts/erc1155/test/generated-wrappers/
+contracts/extensions/generated-wrappers/
+contracts/extensions/test/generated-wrappers/
+contracts/exchange-forwarder/generated-wrappers/
+contracts/exchange-forwarder/test/generated-wrappers/
+contracts/dev-utils/generated-wrappers/
+contracts/dev-utils/test/generated-wrappers/
+contracts/zero-ex/generated-wrappers/
+contracts/zero-ex/test/generated-wrappers/
+contracts/treasury/generated-wrappers/
+contracts/treasury/test/generated-wrappers/
 
 # foundry artifacts
-foundry-artifacts/
+contracts/zero-ex/foundry-artifacts/
 
-# foundry cache
-cache/
-
-#foundry output artifacts
-out/
+# foundry cache 
+contracts/zero-ex/foundry-cache/
 
 # typechain wrappers
 contracts/zero-ex/typechain-wrappers/

.gitmodules

@@ -1,6 +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
-[submodule "contracts/erc20/lib/forge-std"]
-	path = contracts/erc20/lib/forge-std
-	url = https://github.com/foundry-rs/forge-std

.husky/pre-commit

@@ -1,4 +0,0 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-npx lint-staged --no-stash

.prettierignore

@@ -1,10 +1,91 @@
 lib
-deps
 .nyc_output
-generated-artifacts/
-generated-wrappers/
-foundry-artifacts/
-out/
-cache/
+/contracts/broker/generated-wrappers
+/contracts/broker/test/generated-wrappers
+/contracts/broker/generated-artifacts
+/contracts/broker/test/generated-artifacts
+/contracts/integrations/generated-wrappers
+/contracts/integrations/test/generated-wrappers
+/contracts/integrations/generated-artifacts
+/contracts/integrations/test/generated-artifacts
+/contracts/staking/generated-wrappers
+/contracts/staking/test/generated-wrappers
+/contracts/staking/generated-artifacts
+/contracts/staking/test/generated-artifacts
+/contracts/coordinator/generated-wrappers
+/contracts/coordinator/test/generated-wrappers
+/contracts/coordinator/generated-artifacts
+/contracts/coordinator/test/generated-artifacts
+/contracts/exchange/generated-wrappers
+/contracts/exchange/test/generated-wrappers
+/contracts/exchange/generated-artifacts
+/contracts/exchange/test/generated-artifacts
+/contracts/asset-proxy/generated-wrappers
+/contracts/asset-proxy/test/generated-wrappers
+/contracts/asset-proxy/generated-artifacts
+/contracts/asset-proxy/test/generated-artifacts
+/contracts/multisig/generated-wrappers
+/contracts/multisig/test/generated-wrappers
+/contracts/multisig/generated-artifacts
+/contracts/multisig/test/generated-artifacts
+/contracts/utils/generated-wrappers
+/contracts/utils/test/generated-wrappers
+/contracts/utils/generated-artifacts
+/contracts/utils/test/generated-artifacts
+/contracts/exchange-libs/generated-wrappers
+/contracts/exchange-libs/test/generated-wrappers
+/contracts/exchange-libs/generated-artifacts
+/contracts/exchange-libs/test/generated-artifacts
+/contracts/erc20/generated-wrappers
+/contracts/erc20/test/generated-wrappers
+/contracts/erc20/generated-artifacts
+/contracts/erc20/test/generated-artifacts
+/contracts/erc721/generated-wrappers
+/contracts/erc721/test/generated-wrappers
+/contracts/erc721/generated-artifacts
+/contracts/erc721/test/generated-artifacts
+/contracts/erc1155/generated-wrappers
+/contracts/erc1155/test/generated-wrappers
+/contracts/erc1155/generated-artifacts
+/contracts/erc1155/test/generated-artifacts
+/contracts/extensions/generated-wrappers
+/contracts/extensions/test/generated-wrappers
+/contracts/extensions/generated-artifacts
+/contracts/extensions/test/generated-artifacts
+/contracts/exchange-forwarder/generated-wrappers
+/contracts/exchange-forwarder/test/generated-wrappers
+/contracts/exchange-forwarder/generated-artifacts
+/contracts/exchange-forwarder/test/generated-artifacts
+/contracts/dev-utils/generated-wrappers
+/contracts/dev-utils/test/generated-wrappers
+/contracts/dev-utils/generated-artifacts
+/contracts/dev-utils/test/generated-artifacts
+/contracts/zero-ex/foundry-artifacts
+/contracts/zero-ex/generated-wrappers
+/contracts/zero-ex/test/generated-wrappers
+/contracts/zero-ex/generated-artifacts
+/contracts/zero-ex/test/generated-artifacts
+/contracts/treasury/generated-wrappers
+/contracts/treasury/test/generated-wrappers
+/contracts/treasury/generated-artifacts
+/contracts/treasury/test/generated-artifacts
+/contracts/staking/build/
+/contracts/coordinator/build/
+/contracts/exchange/build/
+/contracts/asset-proxy/build/
+/contracts/multisig/build/
+/contracts/utils/build/
+/contracts/exchange-libs/build/
+/contracts/erc20/build/
+/contracts/erc721/build/
+/contracts/erc1155/build/
+/contracts/zero-ex/foundry-artifacts
+/contracts/zero-ex/foundry-cache
+/contracts/zero-ex/contracts/deps
+/contracts/extensions/build/
+/contracts/exchange-forwarder/build/
+/packages/asset-swapper/
+/packages/contract-wrappers/src/generated-wrappers/
 package.json
-packages
+packages/*/docs
+docs/

.solhint.json

@@ -7,7 +7,7 @@
         "avoid-tx-origin": "warn",
         "code-complexity": "off",
         "const-name-snakecase": "error",
-        "function-max-lines": ["error", 350],
+        "function-max-lines": "off",
         "max-line-length": ["error", 120],
         "no-inline-assembly": "off",
         "quotes": ["error", "double"],

.solhintignore

@@ -1,9 +1 @@
-contracts/erc20/src/ZRXToken.sol
-node_modules/
-lib
-deps
-generated-artifacts/
-generated-wrappers/
-foundry-artifacts/
-out/
-cache/
+contracts/erc20/contracts/src/ZRXToken.sol

CODEOWNERS

@@ -8,7 +8,7 @@
 
 # Dev tools & setup
 
-.github/ @dekz
+.circleci/ @dekz
 packages/contract-addresses/ @dekz @dextracker @kyu-c
 packages/contract-artifacts/ @dekz
 packages/protocol-utils/ @dekz

CONTRIBUTING.md

@@ -89,3 +89,15 @@ A few of our coding conventions are not yet enforced by the linter/auto-formatte
 1.  If you _must_ cast a variable to any - try to type it back as fast as possible. (e.g., `const cw = ((zeroEx as any)._contractWrappers as ContractWrappers);`). This ensures subsequent code is type-safe.
 1.  Our enum conventions coincide with the recommended TypeScript conventions, using capitalized keys, and all-caps snake-case values. Eg `GetStats = 'GET_STATS'`
 1.  All public, exported methods/functions/classes must have associated Javadoc-style comments.
+
+### Fix `submit-coverage` CI failure
+
+If you simply fork the repo and then create a PR from it, your PR will fail the `submit-coverage` check on CI. This is because the 0x CircleCI configuration sets the `COVERALLS_REPO_TOKEN` environment variable to the token for `0xProject/0x-tools`, but when running the check against your fork the token needs to match your repo's name `your-username/0x-tools`.
+
+To facilitate this check, after creating your fork, but before creating the branch for your PR, do the following:
+
+1.  Log in to [coveralls.io](https://coveralls.io/), go to `Add Repos`, and enable your fork. Then go to the settings for that repo, and copy the `Repo Token` identifier.
+2.  Log in to [CircleCI](https://circleci.com/login), go to `Add Projects`, click the `Set Up Project` button corresponding to your fork, and then click `Start Building`. (Aside from step 3 below, no actual set up is needed, since it will use the `.circleci/config.yml` file in 0x-tools, so you can ignore all of the instruction/explanation given on the page with the `Start Building` button.)
+3.  In CircleCI, configure your project to add an environment variable, with name `COVERALLS_REPO_TOKEN`, and for the value paste in the `Repo Token` you copied in step 1.
+
+Now, when you push to your branch, CircleCI will automatically run all of the checks in your own instance, and the coverage check will work since it has the proper `Repo Token`, and the PR will magically refer to your own checks rather than running them in the 0x CircleCI instance.

ISSUE_TEMPLATE.md

@@ -2,13 +2,15 @@
 
 <!--- Before submitting please check to see if this issue was already reported -->
 
+<!--- Prefix your issue title with the package name it relates to (e.g., `0x.js: ` or `general:`) -->
+
 ## Expected Behavior
 
 <!--- If you're describing a bug, tell us what should happen -->
 
 <!--- If you're suggesting a package change/improvement, tell us how it should work -->
 
-<!--- If you're suggesting a contract or protocol change/improvement, visit our ZEIPs repo https://github.com/0xProject/ZEIPs -->
+<!--- If you're suggesting a contract or protocol change/improvement, visit our ZEIPs repo -->
 
 ## Current Behavior
 
@@ -48,8 +50,8 @@
 | ------: | :------ |
 
 <!-- For example:
-|    `protocol-utils` | 2.0.4   |
-| `Exchange Contract` | v3      |
+|             `0x.js` | 2.0.4   |
+| `Exchange Contract` | v2      |
 -->
 
 | Network |
@@ -58,6 +60,6 @@
 
 <!-- For example:
 | mainnet |
-| goerli |
-| development |
+| kovan |
+| testrpc |
 -->

README.md

@@ -8,7 +8,8 @@ This repository is a monorepo including the 0x protocol smart contracts and nume
 
 [website-url]: https://0x.org
 
-[![Coverage Status](https://coveralls.io/repos/github/0xProject/protocol/badge.svg?branch=development)](https://coveralls.io/github/0xProject/protocol?branch=development)
+[![CircleCI](https://circleci.com/gh/0xProject/protocol.svg?style=svg&circle-token=61bf7cd8c9b4e11b132089dfcffdd1be277d1e0c)](https://circleci.com/gh/0xProject/protocool)
+[![Coverage Status](https://coveralls.io/repos/github/0xProject/0x-monorepo/badge.svg?branch=development)](https://coveralls.io/github/0xProject/0x-monorepo?branch=development)
 [![Discord](https://img.shields.io/badge/chat-discord.chat-yellow.svg?style=flat)](https://discordapp.com/invite/d3FTX3M)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
@@ -53,7 +54,7 @@ You can include those by prepending the `@0x/typescript-typings` package to your
 
 We strongly recommend that the community help us make improvements and determine the future direction of the protocol. To report bugs within this package, please create an issue in this repository.
 
-#### Read our [contribution guidelines](.github/CONTRIBUTING.md).
+#### Read our [contribution guidelines](./CONTRIBUTING.md).
 
 ### Install dependencies
 

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

@@ -1,48 +1,4 @@
 [
-    {
-        "timestamp": 1677693479,
-        "version": "4.0.1",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "version": "4.0.0",
-        "changes": [
-            {
-                "note": "Migrated package to foundry"
-            }
-        ]
-    },
-    {
-        "timestamp": 1675210931,
-        "version": "3.3.57",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "timestamp": 1675105183,
-        "version": "3.3.56",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "timestamp": 1674517560,
-        "version": "3.3.55",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
     {
         "timestamp": 1670879498,
         "version": "3.3.54",

contracts/erc20/CHANGELOG.md

@@ -5,26 +5,6 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
-## v4.0.1 - _March 1, 2023_
-
-    * Dependencies updated
-
-## v4.0.0 - _Invalid date_
-
-    * Migrated package to foundry
-
-## v3.3.57 - _February 1, 2023_
-
-    * Dependencies updated
-
-## v3.3.56 - _January 30, 2023_
-
-    * Dependencies updated
-
-## v3.3.55 - _January 23, 2023_
-
-    * Dependencies updated
-
 ## v3.3.54 - _December 12, 2022_
 
     * Dependencies updated

contracts/erc20/README.md

@@ -20,7 +20,7 @@ We strongly recommend that the community help us make improvements and determine
 
 For proposals regarding the 0x protocol's smart contract architecture, message format, or additional functionality, go to the [0x Improvement Proposals (ZEIPs)](https://github.com/0xProject/ZEIPs) repository and follow the contribution guidelines provided therein.
 
-Please read our [contribution guidelines](../../.github/CONTRIBUTING.md) before getting started.
+Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.
 
 ### Install Dependencies
 

contracts/erc20/compiler.json

@@ -0,0 +1,28 @@
+{
+    "artifactsDir": "./test/generated-artifacts",
+    "contractsDir": "./contracts",
+    "useDockerisedSolc": false,
+    "isOfflineMode": false,
+    "shouldSaveStandardInput": true,
+    "compilerSettings": {
+        "evmVersion": "istanbul",
+        "optimizer": {
+            "enabled": true,
+            "runs": 1000000,
+            "details": { "yul": true, "deduplicate": true, "cse": true, "constantOptimizer": true }
+        },
+        "outputSelection": {
+            "*": {
+                "*": [
+                    "abi",
+                    "devdoc",
+                    "evm.bytecode.object",
+                    "evm.bytecode.sourceMap",
+                    "evm.deployedBytecode.object",
+                    "evm.deployedBytecode.sourceMap",
+                    "devdoc"
+                ]
+            }
+        }
+    }
+}

contracts/erc20/contracts/src/ERC20Token.sol

@@ -0,0 +1,93 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+import "./interfaces/IERC20Token.sol";
+
+contract ERC20Token is IERC20Token {
+    mapping(address => uint256) internal balances;
+    mapping(address => mapping(address => uint256)) internal allowed;
+
+    uint256 internal _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
+    /// @return True if transfer was successful
+    function transfer(address _to, uint256 _value) external returns (bool) {
+        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(msg.sender, _to, _value);
+
+        return true;
+    }
+
+    /// @dev 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 True if transfer was successful
+    function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {
+        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(_from, _to, _value);
+
+        return true;
+    }
+
+    /// @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) external returns (bool) {
+        allowed[msg.sender][_spender] = _value;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    /// @dev Query total supply of token
+    /// @return Total supply of token
+    function totalSupply() 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) 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) external view returns (uint256) {
+        return allowed[_owner][_spender];
+    }
+}

contracts/erc20/contracts/src/LibERC20Token.sol

@@ -0,0 +1,136 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+import "@0x/contracts-utils/contracts/src/LibRichErrors.sol";
+import "@0x/contracts-utils/contracts/src/LibBytes.sol";
+import "../src/interfaces/IERC20Token.sol";
+
+library LibERC20Token {
+    bytes private constant DECIMALS_CALL_DATA = hex"313ce567";
+
+    /// @dev Calls `IERC20Token(token).approve()`.
+    ///      Reverts if `false` is returned or if the return
+    ///      data length is nonzero and not 32 bytes.
+    /// @param token The address of the token contract.
+    /// @param spender The address that receives an allowance.
+    /// @param allowance The allowance to set.
+    function approve(address token, address spender, uint256 allowance) internal {
+        bytes memory callData = abi.encodeWithSelector(IERC20Token(0).approve.selector, spender, allowance);
+        _callWithOptionalBooleanResult(token, callData);
+    }
+
+    /// @dev Calls `IERC20Token(token).approve()` and sets the allowance to the
+    ///      maximum if the current approval is not already >= an amount.
+    ///      Reverts if `false` is returned or if the return
+    ///      data length is nonzero and not 32 bytes.
+    /// @param token The address of the token contract.
+    /// @param spender The address that receives an allowance.
+    /// @param amount The minimum allowance needed.
+    function approveIfBelow(address token, address spender, uint256 amount) internal {
+        if (IERC20Token(token).allowance(address(this), spender) < amount) {
+            approve(token, spender, uint256(-1));
+        }
+    }
+
+    /// @dev Calls `IERC20Token(token).transfer()`.
+    ///      Reverts if `false` is returned or if the return
+    ///      data length is nonzero and not 32 bytes.
+    /// @param token The address of the token contract.
+    /// @param to The address that receives the tokens
+    /// @param amount Number of tokens to transfer.
+    function transfer(address token, address to, uint256 amount) internal {
+        bytes memory callData = abi.encodeWithSelector(IERC20Token(0).transfer.selector, to, amount);
+        _callWithOptionalBooleanResult(token, callData);
+    }
+
+    /// @dev Calls `IERC20Token(token).transferFrom()`.
+    ///      Reverts if `false` is returned or if the return
+    ///      data length is nonzero and not 32 bytes.
+    /// @param token The address of the token contract.
+    /// @param from The owner of the tokens.
+    /// @param to The address that receives the tokens
+    /// @param amount Number of tokens to transfer.
+    function transferFrom(address token, address from, address to, uint256 amount) internal {
+        bytes memory callData = abi.encodeWithSelector(IERC20Token(0).transferFrom.selector, from, to, amount);
+        _callWithOptionalBooleanResult(token, callData);
+    }
+
+    /// @dev Retrieves the number of decimals for a token.
+    ///      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) internal view returns (uint8 tokenDecimals) {
+        tokenDecimals = 18;
+        (bool didSucceed, bytes memory resultData) = token.staticcall(DECIMALS_CALL_DATA);
+        if (didSucceed && resultData.length == 32) {
+            tokenDecimals = uint8(LibBytes.readUint256(resultData, 0));
+        }
+    }
+
+    /// @dev Retrieves the allowance for a token, owner, and spender.
+    ///      Returns `0` if the call reverts.
+    /// @param token The address of the token contract.
+    /// @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) internal view returns (uint256 allowance_) {
+        (bool didSucceed, bytes memory resultData) = token.staticcall(
+            abi.encodeWithSelector(IERC20Token(0).allowance.selector, owner, spender)
+        );
+        if (didSucceed && resultData.length == 32) {
+            allowance_ = LibBytes.readUint256(resultData, 0);
+        }
+    }
+
+    /// @dev Retrieves the balance for a token owner.
+    ///      Returns `0` if the call reverts.
+    /// @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) internal view returns (uint256 balance) {
+        (bool didSucceed, bytes memory resultData) = token.staticcall(
+            abi.encodeWithSelector(IERC20Token(0).balanceOf.selector, owner)
+        );
+        if (didSucceed && resultData.length == 32) {
+            balance = LibBytes.readUint256(resultData, 0);
+        }
+    }
+
+    /// @dev Executes a call on address `target` with calldata `callData`
+    ///      and asserts that either nothing was returned or a single boolean
+    ///      was returned equal to `true`.
+    /// @param target The call target.
+    /// @param callData The abi-encoded call data.
+    function _callWithOptionalBooleanResult(address target, bytes memory callData) private {
+        (bool didSucceed, bytes memory resultData) = target.call(callData);
+        if (didSucceed) {
+            if (resultData.length == 0) {
+                return;
+            }
+            if (resultData.length == 32) {
+                uint256 result = LibBytes.readUint256(resultData, 0);
+                if (result == 1) {
+                    return;
+                }
+            }
+        }
+        LibRichErrors.rrevert(resultData);
+    }
+}

contracts/erc20/contracts/src/MintableERC20Token.sol

@@ -0,0 +1,46 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
+import "./UnlimitedAllowanceERC20Token.sol";
+
+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) internal {
+        balances[_to] = _value.safeAdd(balances[_to]);
+        _totalSupply = _totalSupply.safeAdd(_value);
+
+        emit Transfer(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) internal {
+        balances[_owner] = balances[_owner].safeSub(_value);
+        _totalSupply = _totalSupply.safeSub(_value);
+
+        emit Transfer(_owner, address(0), _value);
+    }
+}

contracts/erc20/contracts/src/UnlimitedAllowanceERC20Token.sol

@@ -0,0 +1,48 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+import "./ERC20Token.sol";
+
+contract UnlimitedAllowanceERC20Token is ERC20Token {
+    uint256 internal constant 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.
+    /// @param _to Address to transfer to.
+    /// @param _value Amount to transfer.
+    /// @return Success of transfer.
+    function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {
+        uint256 allowance = allowed[_from][msg.sender];
+        require(balances[_from] >= _value, "ERC20_INSUFFICIENT_BALANCE");
+        require(allowance >= _value, "ERC20_INSUFFICIENT_ALLOWANCE");
+        require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");
+
+        balances[_to] += _value;
+        balances[_from] -= _value;
+        if (allowance < MAX_UINT) {
+            allowed[_from][msg.sender] -= _value;
+        }
+
+        emit Transfer(_from, _to, _value);
+
+        return true;
+    }
+}

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

@@ -0,0 +1,57 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+contract IERC20Token {
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+
+    event Approval(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) 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
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return True if transfer was successful
+    function transferFrom(address _from, address _to, uint256 _value) 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) external returns (bool);
+
+    /// @dev Query total supply of token
+    /// @return Total supply of token
+    function totalSupply() external view returns (uint256);
+
+    /// @param _owner The address from which the balance will be retrieved
+    /// @return Balance of owner
+    function balanceOf(address _owner) 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) external view returns (uint256);
+}

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

@@ -0,0 +1,27 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+import "./IERC20Token.sol";
+
+contract IEtherToken is IERC20Token {
+    function deposit() public payable;
+
+    function withdraw(uint256 amount) public;
+}

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

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 /*
 
-  Copyright 2023 ZeroEx Intl.
+  Copyright 2020 ZeroEx Intl.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -17,9 +17,9 @@
 
 */
 
-pragma solidity >=0.6.5 <0.9;
+pragma solidity ^0.6.5;
 
-interface IERC20Token {
+interface IERC20TokenV06 {
     event Transfer(address indexed from, address indexed to, uint256 value);
 
     event Approval(address indexed owner, address indexed spender, uint256 value);

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

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

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

@@ -21,50 +21,50 @@ pragma solidity ^0.6.5;
 
 import "@0x/contracts-utils/contracts/src/v06/errors/LibRichErrorsV06.sol";
 import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
-import "../IERC20Token.sol";
+import "./IERC20TokenV06.sol";
 
 library LibERC20TokenV06 {
     bytes private constant DECIMALS_CALL_DATA = hex"313ce567";
 
-    /// @dev Calls `IERC20Token(token).approve()`.
+    /// @dev Calls `IERC20TokenV06(token).approve()`.
     ///      Reverts if the return data is invalid or the call reverts.
     /// @param token The address of the token contract.
     /// @param spender The address that receives an allowance.
     /// @param allowance The allowance to set.
-    function compatApprove(IERC20Token token, address spender, uint256 allowance) internal {
+    function compatApprove(IERC20TokenV06 token, address spender, uint256 allowance) internal {
         bytes memory callData = abi.encodeWithSelector(token.approve.selector, spender, allowance);
         _callWithOptionalBooleanResult(address(token), callData);
     }
 
-    /// @dev Calls `IERC20Token(token).approve()` and sets the allowance to the
+    /// @dev Calls `IERC20TokenV06(token).approve()` and sets the allowance to the
     ///      maximum if the current approval is not already >= an amount.
     ///      Reverts if the return data is invalid or the call reverts.
     /// @param token The address of the token contract.
     /// @param spender The address that receives an allowance.
     /// @param amount The minimum allowance needed.
-    function approveIfBelow(IERC20Token token, address spender, uint256 amount) internal {
+    function approveIfBelow(IERC20TokenV06 token, address spender, uint256 amount) internal {
         if (token.allowance(address(this), spender) < amount) {
             compatApprove(token, spender, uint256(-1));
         }
     }
 
-    /// @dev Calls `IERC20Token(token).transfer()`.
+    /// @dev Calls `IERC20TokenV06(token).transfer()`.
     ///      Reverts if the return data is invalid or the call reverts.
     /// @param token The address of the token contract.
     /// @param to The address that receives the tokens
     /// @param amount Number of tokens to transfer.
-    function compatTransfer(IERC20Token token, address to, uint256 amount) internal {
+    function compatTransfer(IERC20TokenV06 token, address to, uint256 amount) internal {
         bytes memory callData = abi.encodeWithSelector(token.transfer.selector, to, amount);
         _callWithOptionalBooleanResult(address(token), callData);
     }
 
-    /// @dev Calls `IERC20Token(token).transferFrom()`.
+    /// @dev Calls `IERC20TokenV06(token).transferFrom()`.
     ///      Reverts if the return data is invalid or the call reverts.
     /// @param token The address of the token contract.
     /// @param from The owner of the tokens.
     /// @param to The address that receives the tokens
     /// @param amount Number of tokens to transfer.
-    function compatTransferFrom(IERC20Token token, address from, address to, uint256 amount) internal {
+    function compatTransferFrom(IERC20TokenV06 token, address from, address to, uint256 amount) internal {
         bytes memory callData = abi.encodeWithSelector(token.transferFrom.selector, from, to, amount);
         _callWithOptionalBooleanResult(address(token), callData);
     }
@@ -73,7 +73,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(IERC20Token token) internal view returns (uint8 tokenDecimals) {
+    function compatDecimals(IERC20TokenV06 token) internal view returns (uint8 tokenDecimals) {
         tokenDecimals = 18;
         (bool didSucceed, bytes memory resultData) = address(token).staticcall(DECIMALS_CALL_DATA);
         if (didSucceed && resultData.length >= 32) {
@@ -88,7 +88,7 @@ library LibERC20TokenV06 {
     /// @param spender The address the spender.
     /// @return allowance_ The allowance for a token, owner, and spender.
     function compatAllowance(
-        IERC20Token token,
+        IERC20TokenV06 token,
         address owner,
         address spender
     ) internal view returns (uint256 allowance_) {
@@ -105,7 +105,7 @@ 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(IERC20Token token, address owner) internal view returns (uint256 balance) {
+    function compatBalanceOf(IERC20TokenV06 token, address owner) internal view returns (uint256 balance) {
         (bool didSucceed, bytes memory resultData) = address(token).staticcall(
             abi.encodeWithSelector(token.balanceOf.selector, owner)
         );

contracts/erc20/contracts/test/DummyERC20Token.sol

@@ -0,0 +1,61 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.5;
+
+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 {
+    using LibSafeMath for uint256;
+
+    string public name;
+    string public symbol;
+    uint256 public decimals;
+    uint256 public constant MAX_MINT_AMOUNT = 10000000000000000000000;
+
+    constructor(string memory _name, string memory _symbol, uint256 _decimals, uint256 _totalSupply) public {
+        name = _name;
+        symbol = _symbol;
+        decimals = _decimals;
+        _totalSupply = _totalSupply;
+        balances[msg.sender] = _totalSupply;
+    }
+
+    /// @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) external onlyOwner {
+        uint256 currBalance = balances[_target];
+        if (_value < currBalance) {
+            _totalSupply = _totalSupply.safeSub(currBalance.safeSub(_value));
+        } else {
+            _totalSupply = _totalSupply.safeAdd(_value.safeSub(currBalance));
+        }
+        balances[_target] = _value;
+    }
+
+    /// @dev Mints new tokens for sender
+    /// @param _value Amount of tokens to mint
+    function mint(uint256 _value) external {
+        require(_value <= MAX_MINT_AMOUNT, "VALUE_TOO_LARGE");
+
+        _mint(msg.sender, _value);
+    }
+}

contracts/erc20/contracts/test/DummyMultipleReturnERC20Token.sol

@@ -0,0 +1,46 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.5;
+
+import "./DummyERC20Token.sol";
+
+contract DummyMultipleReturnERC20Token is DummyERC20Token {
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint256 _decimals,
+        uint256 _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
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    function transferFrom(address _from, address _to, uint256 _value) external 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 {
+            mstore(0, 1)
+            mstore(32, 1)
+            return(0, 64)
+        }
+    }
+}

contracts/erc20/contracts/test/DummyNoReturnERC20Token.sol

@@ -0,0 +1,69 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.5;
+
+import "./DummyERC20Token.sol";
+
+contract DummyNoReturnERC20Token is DummyERC20Token {
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint256 _decimals,
+        uint256 _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) external returns (bool) {
+        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(msg.sender, _to, _value);
+
+        // HACK: This contract will not compile if we remove `returns (bool)`, so we manually return no data
+        assembly {
+            return(0, 0)
+        }
+    }
+
+    /// @dev 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
+    function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {
+        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(_from, _to, _value);
+
+        // HACK: This contract will not compile if we remove `returns (bool)`, so we manually return no data
+        assembly {
+            return(0, 0)
+        }
+    }
+}

contracts/erc20/contracts/test/TestLibERC20Token.sol

@@ -0,0 +1,73 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+import "../src/LibERC20Token.sol";
+import "./TestLibERC20TokenTarget.sol";
+
+contract TestLibERC20Token {
+    TestLibERC20TokenTarget public target;
+
+    constructor() public {
+        target = new TestLibERC20TokenTarget();
+    }
+
+    function testApprove(
+        bool shouldRevert,
+        bytes calldata revertData,
+        bytes calldata returnData,
+        address spender,
+        uint256 allowance
+    ) external {
+        target.setBehavior(shouldRevert, revertData, returnData);
+        LibERC20Token.approve(address(target), spender, allowance);
+    }
+
+    function testTransfer(
+        bool shouldRevert,
+        bytes calldata revertData,
+        bytes calldata returnData,
+        address to,
+        uint256 amount
+    ) external {
+        target.setBehavior(shouldRevert, revertData, returnData);
+        LibERC20Token.transfer(address(target), to, amount);
+    }
+
+    function testTransferFrom(
+        bool shouldRevert,
+        bytes calldata revertData,
+        bytes calldata returnData,
+        address from,
+        address to,
+        uint256 amount
+    ) external {
+        target.setBehavior(shouldRevert, revertData, returnData);
+        LibERC20Token.transferFrom(address(target), from, to, amount);
+    }
+
+    function testDecimals(
+        bool shouldRevert,
+        bytes calldata revertData,
+        bytes calldata returnData
+    ) external returns (uint8) {
+        target.setBehavior(shouldRevert, revertData, returnData);
+        return LibERC20Token.decimals(address(target));
+    }
+}

contracts/erc20/contracts/test/TestLibERC20TokenTarget.sol

@@ -0,0 +1,69 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+contract TestLibERC20TokenTarget {
+    event ApproveCalled(address spender, uint256 allowance);
+
+    event TransferCalled(address to, uint256 amount);
+
+    event TransferFromCalled(address from, address to, uint256 amount);
+
+    bool private _shouldRevert;
+    bytes private _revertData;
+    bytes private _returnData;
+
+    function setBehavior(bool shouldRevert, bytes calldata revertData, bytes calldata returnData) external {
+        _shouldRevert = shouldRevert;
+        _revertData = revertData;
+        _returnData = returnData;
+    }
+
+    function approve(address spender, uint256 allowance) external returns (bool) {
+        emit ApproveCalled(spender, allowance);
+        _execute();
+    }
+
+    function transfer(address to, uint256 amount) external returns (bool) {
+        emit TransferCalled(to, amount);
+        _execute();
+    }
+
+    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
+        emit TransferFromCalled(from, to, amount);
+        _execute();
+    }
+
+    function decimals() external view returns (uint8) {
+        _execute();
+    }
+
+    function _execute() private view {
+        if (_shouldRevert) {
+            bytes memory revertData = _revertData;
+            assembly {
+                revert(add(revertData, 0x20), mload(revertData))
+            }
+        }
+        bytes memory returnData = _returnData;
+        assembly {
+            return(add(returnData, 0x20), mload(returnData))
+        }
+    }
+}

contracts/erc20/contracts/test/UntransferrableDummyERC20Token.sol

@@ -0,0 +1,38 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.5;
+
+import "./DummyERC20Token.sol";
+
+contract UntransferrableDummyERC20Token is DummyERC20Token {
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint256 _decimals,
+        uint256 _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
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {
+        require(false, "TRANSFER_DISABLED");
+    }
+}

contracts/erc20/foundry.toml

@@ -1,18 +0,0 @@
-[profile.default]
-src = 'src'
-out = 'out'
-libs = [
-    'lib',
-    'node_modules',
-]
-remappings = [
-    '@0x/contracts-utils/=../utils/'
-]
-allow_paths = [
-    '../utils/'
-]
-
-fs_permissions = [{ access = "read", path = "./out/ZRXToken.sol" }]
-
-optimizer_runs = 1_000_000
-# See more config options https://github.com/foundry-rs/foundry/tree/master/config

contracts/erc20/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-erc20",
-    "version": "4.0.1",
+    "version": "3.3.54",
     "engines": {
         "node": ">=6.12"
     },
@@ -10,10 +10,36 @@
         "test": "test"
     },
     "scripts": {
-        "test:ci": "forge test",
+        "build": "yarn pre_build && tsc -b",
+        "build:ci": "yarn build",
+        "pre_build": "run-s compile contracts:gen generate_contract_wrappers contracts:copy",
+        "test": "yarn run_mocha",
+        "rebuild_and_test": "run-s build test",
+        "test:coverage": "SOLIDITY_COVERAGE=true run-s build run_mocha coverage:report:text coverage:report:lcov",
+        "test:profiler": "SOLIDITY_PROFILER=true run-s build run_mocha profiler:report:html",
+        "test:trace": "SOLIDITY_REVERT_TRACE=true run-s build run_mocha",
+        "run_mocha": "mocha --require source-map-support/register --require make-promises-safe 'lib/test/**/*.js' --timeout 100000 --bail --exit",
+        "compile": "sol-compiler",
+        "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": "eslint src test",
+        "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",
+        "coverage:report:lcov": "istanbul report lcov",
+        "test:circleci": "yarn test",
+        "contracts:gen": "contracts-gen generate",
+        "contracts:copy": "contracts-gen copy",
         "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"
     },
+    "config": {
+        "publicInterfaceContracts": "DummyERC20Token,ERC20Token,WETH9,ZRXToken,DummyNoReturnERC20Token,DummyMultipleReturnERC20Token",
+        "abis": "./test/generated-artifacts/@(DummyERC20Token|DummyMultipleReturnERC20Token|DummyNoReturnERC20Token|ERC20Token|IERC20Token|IERC20TokenV06|IEtherToken|IEtherTokenV06|LibERC20Token|LibERC20TokenV06|MintableERC20Token|TestLibERC20Token|TestLibERC20TokenTarget|UnlimitedAllowanceERC20Token|UntransferrableDummyERC20Token|WETH9|WETH9V06|ZRXToken).json",
+        "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually."
+    },
     "repository": {
         "type": "git",
         "url": "https://github.com/0xProject/protocol.git"
@@ -22,11 +48,42 @@
     "bugs": {
         "url": "https://github.com/0xProject/protocol/issues"
     },
-    "homepage": "https://github.com/0xProject/protocol",
+    "homepage": "https://github.com/0xProject/protocol/tree/main/contracts/tokens",
     "devDependencies": {
-        "@0x/contracts-utils": "^4.8.39",
+        "@0x/abi-gen": "^5.8.1",
+        "@0x/contracts-gen": "^2.0.48",
+        "@0x/contracts-test-utils": "^5.4.44",
+        "@0x/contracts-utils": "^4.8.35",
+        "@0x/dev-utils": "^5.0.0",
+        "@0x/sol-compiler": "^4.8.2",
         "@0x/ts-doc-gen": "^0.0.28",
-        "typedoc": "~0.16.11"
+        "@0x/types": "^3.3.6",
+        "@0x/typescript-typings": "^5.3.1",
+        "@0x/utils": "^7.0.0",
+        "@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",
+        "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",
+        "typedoc": "~0.16.11",
+        "typescript": "4.6.3"
+    },
+    "dependencies": {
+        "@0x/base-contract": "^7.0.0",
+        "ethers": "~4.0.4"
     },
     "publishConfig": {
         "access": "public"

contracts/erc20/src/artifacts.ts

@@ -0,0 +1,21 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+import { ContractArtifact } from 'ethereum-types';
+
+import * as DummyERC20Token from '../generated-artifacts/DummyERC20Token.json';
+import * as DummyMultipleReturnERC20Token from '../generated-artifacts/DummyMultipleReturnERC20Token.json';
+import * as DummyNoReturnERC20Token from '../generated-artifacts/DummyNoReturnERC20Token.json';
+import * as ERC20Token from '../generated-artifacts/ERC20Token.json';
+import * as WETH9 from '../generated-artifacts/WETH9.json';
+import * as ZRXToken from '../generated-artifacts/ZRXToken.json';
+export const artifacts = {
+    DummyERC20Token: DummyERC20Token as ContractArtifact,
+    ERC20Token: ERC20Token as ContractArtifact,
+    WETH9: WETH9 as ContractArtifact,
+    ZRXToken: ZRXToken as any as ContractArtifact,
+    DummyNoReturnERC20Token: DummyNoReturnERC20Token as ContractArtifact,
+    DummyMultipleReturnERC20Token: DummyMultipleReturnERC20Token as ContractArtifact,
+};

contracts/erc20/src/index.ts

@@ -0,0 +1,47 @@
+export {
+    DummyERC20TokenContract,
+    DummyMultipleReturnERC20TokenContract,
+    DummyNoReturnERC20TokenContract,
+    WETH9Contract,
+    WETH9Events,
+    WETH9DepositEventArgs,
+    WETH9TransferEventArgs,
+    WETH9WithdrawalEventArgs,
+    ZRXTokenContract,
+    DummyERC20TokenTransferEventArgs,
+    ERC20TokenEventArgs,
+    ERC20TokenEvents,
+    ERC20TokenTransferEventArgs,
+    ERC20TokenApprovalEventArgs,
+    ERC20TokenContract,
+} from './wrappers';
+export { artifacts } from './artifacts';
+export {
+    ContractArtifact,
+    ContractChains,
+    CompilerOpts,
+    StandardContractOutput,
+    CompilerSettings,
+    ContractChainData,
+    ContractAbi,
+    DevdocOutput,
+    EvmOutput,
+    CompilerSettingsMetadata,
+    OptimizerSettings,
+    OutputField,
+    ParamDescription,
+    EvmBytecodeOutput,
+    EvmBytecodeOutputLinkReferences,
+    AbiDefinition,
+    FunctionAbi,
+    EventAbi,
+    RevertErrorAbi,
+    EventParameter,
+    DataItem,
+    MethodAbi,
+    ConstructorAbi,
+    FallbackAbi,
+    ConstructorStateMutability,
+    TupleDataItem,
+    StateMutability,
+} from 'ethereum-types';

contracts/erc20/src/v08/LibERC20TokenV08.sol

@@ -1,146 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
-
-  Copyright 2020 ZeroEx Intl.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-*/
-
-pragma solidity ^0.8.0;
-
-import "@0x/contracts-utils/contracts/src/v08/errors/LibRichErrorsV08.sol";
-import "@0x/contracts-utils/contracts/src/v08/LibBytesV08.sol";
-import "../IERC20Token.sol";
-
-library LibERC20TokenV08 {
-    bytes private constant DECIMALS_CALL_DATA = hex"313ce567";
-
-    /// @dev Calls `IERC20Token(token).approve()`.
-    ///      Reverts if the return data is invalid or the call reverts.
-    /// @param token The address of the token contract.
-    /// @param spender The address that receives an allowance.
-    /// @param allowance The allowance to set.
-    function compatApprove(IERC20Token token, address spender, uint256 allowance) internal {
-        bytes memory callData = abi.encodeCall(token.approve, (spender, allowance));
-        _callWithOptionalBooleanResult(address(token), callData);
-    }
-
-    /// @dev Calls `IERC20Token(token).approve()` and sets the allowance to the
-    ///      maximum if the current approval is not already >= an amount.
-    ///      Reverts if the return data is invalid or the call reverts.
-    /// @param token The address of the token contract.
-    /// @param spender The address that receives an allowance.
-    /// @param amount The minimum allowance needed.
-    function approveIfBelow(IERC20Token token, address spender, uint256 amount) internal {
-        if (token.allowance(address(this), spender) < amount) {
-            compatApprove(token, spender, type(uint256).max);
-        }
-    }
-
-    /// @dev Calls `IERC20Token(token).transfer()`.
-    ///      Reverts if the return data is invalid or the call reverts.
-    /// @param token The address of the token contract.
-    /// @param to The address that receives the tokens
-    /// @param amount Number of tokens to transfer.
-    function compatTransfer(IERC20Token token, address to, uint256 amount) internal {
-        bytes memory callData = abi.encodeCall(token.transfer, (to, amount));
-        _callWithOptionalBooleanResult(address(token), callData);
-    }
-
-    /// @dev Calls `IERC20Token(token).transferFrom()`.
-    ///      Reverts if the return data is invalid or the call reverts.
-    /// @param token The address of the token contract.
-    /// @param from The owner of the tokens.
-    /// @param to The address that receives the tokens
-    /// @param amount Number of tokens to transfer.
-    function compatTransferFrom(IERC20Token token, address from, address to, uint256 amount) internal {
-        bytes memory callData = abi.encodeCall(token.transferFrom, (from, to, amount));
-        _callWithOptionalBooleanResult(address(token), callData);
-    }
-
-    /// @dev Retrieves the number of decimals for a token.
-    ///      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(IERC20Token token) internal view returns (uint8 tokenDecimals) {
-        tokenDecimals = 18;
-        (bool didSucceed, bytes memory resultData) = address(token).staticcall(DECIMALS_CALL_DATA);
-        if (didSucceed && resultData.length >= 32) {
-            tokenDecimals = abi.decode(resultData, (uint8));
-        }
-    }
-
-    /// @dev Retrieves the allowance for a token, owner, and spender.
-    ///      Returns `0` if the call reverts.
-    /// @param token The address of the token contract.
-    /// @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(
-        IERC20Token token,
-        address owner,
-        address spender
-    ) internal view returns (uint256 allowance_) {
-        (bool didSucceed, bytes memory resultData) = address(token).staticcall(
-            abi.encodeCall(token.allowance, (owner, spender))
-        );
-        if (didSucceed && resultData.length >= 32) {
-            allowance_ = abi.decode(resultData, (uint256));
-        }
-    }
-
-    /// @dev Retrieves the balance for a token owner.
-    ///      Returns `0` if the call reverts.
-    /// @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(IERC20Token token, address owner) internal view returns (uint256 balance) {
-        (bool didSucceed, bytes memory resultData) = address(token).staticcall(
-            abi.encodeCall(token.balanceOf, (owner))
-        );
-        if (didSucceed && resultData.length >= 32) {
-            balance = abi.decode(resultData, (uint256));
-        }
-    }
-
-    /// @dev Executes a call on address `target` with calldata `callData`
-    ///      and asserts that either nothing was returned or a single boolean
-    ///      was returned equal to `true`.
-    /// @param target The call target.
-    /// @param callData The abi-encoded call data.
-    function _callWithOptionalBooleanResult(address target, bytes memory callData) private {
-        (bool didSucceed, bytes memory resultData) = target.call(callData);
-        // Revert if the call reverted.
-        if (!didSucceed) {
-            LibRichErrorsV08.rrevert(resultData);
-        }
-        // If we get back 0 returndata, this may be a non-standard ERC-20 that
-        // does not return a boolean. Check that it at least contains code.
-        if (resultData.length == 0) {
-            require(target.code.length > 0, "invalid token address, contains no code");
-            return;
-        }
-        // If we get back at least 32 bytes, we know the target address
-        // contains code, and we assume it is a token that returned a boolean
-        // success value, which must be true.
-        if (resultData.length >= 32) {
-            if (!abi.decode(resultData, (bool))) {
-                LibRichErrorsV08.rrevert(resultData);
-            }
-        }
-        // If 0 < returndatasize < 32, the target is a contract, but not a
-        // valid token.
-        LibRichErrorsV08.rrevert(resultData);
-    }
-}

contracts/erc20/src/wrappers.ts

@@ -0,0 +1,11 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+export * from '../generated-wrappers/dummy_erc20_token';
+export * from '../generated-wrappers/dummy_multiple_return_erc20_token';
+export * from '../generated-wrappers/dummy_no_return_erc20_token';
+export * from '../generated-wrappers/erc20_token';
+export * from '../generated-wrappers/weth9';
+export * from '../generated-wrappers/zrx_token';

contracts/erc20/test/WETH9V06Test.t.sol

@@ -1,76 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
-  Copyright 2023 ZeroEx Intl.
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-pragma solidity ^0.6.5;
-pragma experimental ABIEncoderV2;
-
-import "forge-std/Test.sol";
-import "../src/v06/WETH9V06.sol";
-
-contract WETH9V06Test is Test {
-    address payable internal owner = payable(vm.addr(1));
-    address payable internal user = payable(vm.addr(2));
-    WETH9V06 internal etherToken;
-
-    function setUp() public {
-        vm.deal(owner, 1e20);
-        vm.deal(user, 1e20);
-
-        etherToken = new WETH9V06();
-    }
-
-    function testShouldRevertIfCallerAttemptsToDepositMoreThanTheirBalance() public {
-        vm.prank(user);
-        vm.expectRevert();
-        etherToken.deposit{value: 1e20 + 1}();
-    }
-
-    function testShouldConvertDepositedETHToWrappedETH() public {
-        vm.prank(user);
-        etherToken.deposit{value: 1e20}();
-        vm.stopPrank();
-
-        assertEq(etherToken.balanceOf(user), 1e20);
-        assertEq(address(etherToken).balance, 1e20);
-    }
-
-    function testShouldRevertIfCallerAttemptsToWithdrawMoreThanTheirBalance() public {
-        vm.prank(user);
-        etherToken.deposit{value: 1e20}();
-
-        vm.expectRevert();
-        etherToken.withdraw(1e20 + 1);
-    }
-
-    function testShouldConvertWithdrawWrappedETHToETH() public {
-        vm.prank(user);
-        etherToken.deposit{value: 1e20}();
-        vm.prank(user);
-        etherToken.withdraw(100);
-        vm.stopPrank();
-
-        assertEq(etherToken.balanceOf(user), 1e20 - 100);
-        assertEq(address(etherToken).balance, 1e20 - 100);
-        assertEq(user.balance, 100);
-    }
-
-    function testShouldConvertSentETHToWrappedETH() public {
-        vm.prank(user);
-        address(etherToken).call{value: 1e20}(new bytes(0));
-        vm.stopPrank();
-
-        assertEq(etherToken.balanceOf(user), 1e20);
-        assertEq(address(etherToken).balance, 1e20);
-    }
-}

contracts/erc20/test/ZRXTokenTest.t.sol

@@ -1,117 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
-  Copyright 2023 ZeroEx Intl.
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-pragma solidity ^0.8.17;
-
-import "forge-std/Test.sol";
-import "../src/IERC20Token.sol";
-
-contract ZRXTokenTest is Test {
-    address payable internal owner = payable(vm.addr(1));
-    address payable internal user = payable(vm.addr(2));
-    address payable internal anotherUser = payable(vm.addr(3));
-    uint256 internal totalSupply = 1_000_000_000 * 1e18;
-    IERC20Token zrxToken;
-
-    function setUp() public {
-        vm.deal(owner, 1e20);
-        vm.deal(user, 1e20);
-
-        vm.prank(owner);
-        bytes memory _bytecode = vm.getCode("./out/ZRXToken.sol/ZRXToken.json");
-        address _address;
-        assembly {
-            _address := create(0, add(_bytecode, 0x20), mload(_bytecode))
-        }
-        vm.stopPrank();
-        zrxToken = IERC20Token(address(_address));
-    }
-
-    function testShouldHave18Decimals() public {
-        assertEq(zrxToken.decimals(), 18);
-    }
-
-    function testShouldHaveTotalSupplyOf1Billion() public {
-        assertEq(zrxToken.totalSupply(), totalSupply);
-    }
-
-    function testShouldInitializeOwnerBalanceToTotalSupply() public {
-        assertEq(zrxToken.balanceOf(owner), totalSupply);
-    }
-
-    function testShouldTransferBalanceCorrectly() public {
-        vm.prank(owner);
-        zrxToken.transfer(user, 100);
-
-        assertEq(zrxToken.balanceOf(user), 100);
-        assertEq(zrxToken.balanceOf(owner), totalSupply - 100);
-    }
-
-    function testShouldReturnTrueOnAZeroValueTransfer() public {
-        vm.prank(owner);
-        bool success = zrxToken.transfer(user, 0);
-        assertTrue(success);
-    }
-
-    function testShouldReturnTrueOnAZeroValueTransferByUserWithZeroBalance() public {
-        vm.prank(anotherUser);
-        bool success = zrxToken.transfer(user, 0);
-        assertTrue(success);
-    }
-
-    function testShouldReturnFalseIfSenderHasInsufficientBalance() public {
-        vm.prank(owner);
-        zrxToken.approve(user, totalSupply + 1);
-        vm.stopPrank();
-
-        bool success = zrxToken.transferFrom(owner, user, totalSupply + 1);
-        assertEq(success, false);
-    }
-
-    function testShouldReturnFalseIfRecipientHasInsufficientAllowance() public {
-        vm.prank(owner);
-        zrxToken.approve(user, totalSupply - 1);
-        vm.stopPrank();
-
-        bool success = zrxToken.transferFrom(owner, user, totalSupply);
-        assertEq(success, false);
-    }
-
-    function testShouldReturnTrueOnAZeroValueApprovedTransfer() public {
-        vm.prank(user);
-        bool success = zrxToken.transferFrom(owner, user, 0);
-        assertEq(success, true);
-    }
-
-    function testShouldNotModifySenderAllowanceIfSetToUINT256Max() public {
-        vm.prank(owner);
-        zrxToken.approve(user, type(uint256).max);
-        vm.stopPrank();
-
-        zrxToken.transferFrom(owner, user, 100);
-        assertEq(zrxToken.allowance(owner, user), type(uint256).max);
-    }
-
-    function testShouldTransferCorrectlyWhenSufficientAllowance() public {
-        vm.prank(owner);
-        zrxToken.approve(user, 1000 * 1e18);
-        vm.stopPrank();
-
-        vm.prank(user);
-        zrxToken.transferFrom(owner, user, 100 * 1e18);
-        assertEq(zrxToken.allowance(owner, user), 900 * 1e18);
-        assertEq(zrxToken.balanceOf(user), 100 * 1e18);
-        assertEq(zrxToken.balanceOf(owner), totalSupply - 100 * 1e18);
-    }
-}

contracts/erc20/test/artifacts.ts

@@ -0,0 +1,45 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+import { ContractArtifact } from 'ethereum-types';
+
+import * as DummyERC20Token from '../test/generated-artifacts/DummyERC20Token.json';
+import * as DummyMultipleReturnERC20Token from '../test/generated-artifacts/DummyMultipleReturnERC20Token.json';
+import * as DummyNoReturnERC20Token from '../test/generated-artifacts/DummyNoReturnERC20Token.json';
+import * as ERC20Token from '../test/generated-artifacts/ERC20Token.json';
+import * as IERC20Token from '../test/generated-artifacts/IERC20Token.json';
+import * as IERC20TokenV06 from '../test/generated-artifacts/IERC20TokenV06.json';
+import * as IEtherToken from '../test/generated-artifacts/IEtherToken.json';
+import * as IEtherTokenV06 from '../test/generated-artifacts/IEtherTokenV06.json';
+import * as LibERC20Token from '../test/generated-artifacts/LibERC20Token.json';
+import * as LibERC20TokenV06 from '../test/generated-artifacts/LibERC20TokenV06.json';
+import * as MintableERC20Token from '../test/generated-artifacts/MintableERC20Token.json';
+import * as TestLibERC20Token from '../test/generated-artifacts/TestLibERC20Token.json';
+import * as TestLibERC20TokenTarget from '../test/generated-artifacts/TestLibERC20TokenTarget.json';
+import * as UnlimitedAllowanceERC20Token from '../test/generated-artifacts/UnlimitedAllowanceERC20Token.json';
+import * as UntransferrableDummyERC20Token from '../test/generated-artifacts/UntransferrableDummyERC20Token.json';
+import * as WETH9 from '../test/generated-artifacts/WETH9.json';
+import * as WETH9V06 from '../test/generated-artifacts/WETH9V06.json';
+import * as ZRXToken from '../test/generated-artifacts/ZRXToken.json';
+export const artifacts = {
+    ERC20Token: ERC20Token as ContractArtifact,
+    LibERC20Token: LibERC20Token as ContractArtifact,
+    MintableERC20Token: MintableERC20Token as ContractArtifact,
+    UnlimitedAllowanceERC20Token: UnlimitedAllowanceERC20Token as ContractArtifact,
+    WETH9: WETH9 as ContractArtifact,
+    ZRXToken: ZRXToken as any as ContractArtifact,
+    IERC20Token: IERC20Token as ContractArtifact,
+    IEtherToken: IEtherToken as ContractArtifact,
+    IERC20TokenV06: IERC20TokenV06 as ContractArtifact,
+    IEtherTokenV06: IEtherTokenV06 as ContractArtifact,
+    LibERC20TokenV06: LibERC20TokenV06 as ContractArtifact,
+    WETH9V06: WETH9V06 as ContractArtifact,
+    DummyERC20Token: DummyERC20Token as ContractArtifact,
+    DummyMultipleReturnERC20Token: DummyMultipleReturnERC20Token as ContractArtifact,
+    DummyNoReturnERC20Token: DummyNoReturnERC20Token as ContractArtifact,
+    TestLibERC20Token: TestLibERC20Token as ContractArtifact,
+    TestLibERC20TokenTarget: TestLibERC20TokenTarget as ContractArtifact,
+    UntransferrableDummyERC20Token: UntransferrableDummyERC20Token as ContractArtifact,
+};

contracts/erc20/test/global_hooks.ts

@@ -0,0 +1,19 @@
+import { env, EnvVars } from '@0x/dev-utils';
+
+import { coverage, profiler, provider } from '@0x/contracts-test-utils';
+import { providerUtils } from '@0x/utils';
+
+before('start web3 provider', () => {
+    providerUtils.startProviderEngine(provider);
+});
+after('generate coverage report', async () => {
+    if (env.parseBoolean(EnvVars.SolidityCoverage)) {
+        const coverageSubprovider = coverage.getCoverageSubproviderSingleton();
+        await coverageSubprovider.writeCoverageAsync();
+    }
+    if (env.parseBoolean(EnvVars.SolidityProfiler)) {
+        const profilerSubprovider = profiler.getProfilerSubproviderSingleton();
+        await profilerSubprovider.writeProfilerOutputAsync();
+    }
+    provider.stop();
+});

contracts/erc20/test/lib_erc20_token.ts

@@ -0,0 +1,335 @@
+import {
+    blockchainTests,
+    constants,
+    expect,
+    getRandomInteger,
+    randomAddress,
+    verifyEventsFromLogs,
+} from '@0x/contracts-test-utils';
+import { hexUtils, RawRevertError, StringRevertError } from '@0x/utils';
+
+import { TestLibERC20TokenContract, TestLibERC20TokenTargetEvents } from './wrappers';
+
+import { artifacts } from './artifacts';
+
+blockchainTests('LibERC20Token', env => {
+    let testContract: TestLibERC20TokenContract;
+    const REVERT_STRING = 'WHOOPSIE';
+    const ENCODED_REVERT = new StringRevertError(REVERT_STRING).encode();
+    const ENCODED_TRUE = hexUtils.leftPad(1);
+    const ENCODED_FALSE = hexUtils.leftPad(0);
+    const ENCODED_TWO = hexUtils.leftPad(2);
+    const ENCODED_SHORT_TRUE = hexUtils.leftPad(2, 31);
+    const ENCODED_LONG_TRUE = hexUtils.leftPad(2, 33);
+
+    before(async () => {
+        testContract = await TestLibERC20TokenContract.deployFrom0xArtifactAsync(
+            artifacts.TestLibERC20Token,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+        );
+    });
+
+    describe('approve()', () => {
+        it('calls the target with the correct arguments', async () => {
+            const spender = randomAddress();
+            const allowance = getRandomInteger(0, 100e18);
+            const { logs } = await testContract
+                .testApprove(false, ENCODED_REVERT, ENCODED_TRUE, spender, allowance)
+                .awaitTransactionSuccessAsync();
+            expect(logs).to.be.length(1);
+            verifyEventsFromLogs(logs, [{ spender, allowance }], TestLibERC20TokenTargetEvents.ApproveCalled);
+        });
+
+        it('succeeds if the target returns true', async () => {
+            const spender = randomAddress();
+            const allowance = getRandomInteger(0, 100e18);
+            await testContract
+                .testApprove(false, ENCODED_REVERT, ENCODED_TRUE, spender, allowance)
+                .awaitTransactionSuccessAsync();
+        });
+
+        it('succeeds if the target returns nothing', async () => {
+            const spender = randomAddress();
+            const allowance = getRandomInteger(0, 100e18);
+            await testContract
+                .testApprove(false, ENCODED_REVERT, constants.NULL_BYTES, spender, allowance)
+                .awaitTransactionSuccessAsync();
+        });
+
+        it('fails if the target returns false', async () => {
+            const spender = randomAddress();
+            const allowance = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testApprove(false, ENCODED_REVERT, ENCODED_FALSE, spender, allowance)
+                .awaitTransactionSuccessAsync();
+            const expectedError = new RawRevertError(ENCODED_FALSE);
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('fails if the target returns nonzero and not true', async () => {
+            const spender = randomAddress();
+            const allowance = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testApprove(false, ENCODED_REVERT, ENCODED_TWO, spender, allowance)
+                .awaitTransactionSuccessAsync();
+            const expectedError = new RawRevertError(ENCODED_TWO);
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('fails if the target returns less than 32 bytes', async () => {
+            const spender = randomAddress();
+            const allowance = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testApprove(false, ENCODED_REVERT, ENCODED_SHORT_TRUE, spender, allowance)
+                .awaitTransactionSuccessAsync();
+            const expectedError = new RawRevertError(ENCODED_SHORT_TRUE);
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('fails if the target returns greater than 32 bytes', async () => {
+            const spender = randomAddress();
+            const allowance = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testApprove(false, ENCODED_REVERT, ENCODED_LONG_TRUE, spender, allowance)
+                .awaitTransactionSuccessAsync();
+            const expectedError = new RawRevertError(ENCODED_LONG_TRUE);
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('fails if the target reverts', async () => {
+            const spender = randomAddress();
+            const allowance = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testApprove(true, ENCODED_REVERT, ENCODED_TRUE, spender, allowance)
+                .awaitTransactionSuccessAsync();
+            return expect(tx).to.revertWith(REVERT_STRING);
+        });
+
+        it('fails if the target reverts with no data', async () => {
+            const spender = randomAddress();
+            const allowance = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testApprove(true, constants.NULL_BYTES, ENCODED_TRUE, spender, allowance)
+                .awaitTransactionSuccessAsync();
+            return expect(tx).to.be.rejectedWith('revert');
+        });
+    });
+
+    describe('transfer()', () => {
+        it('calls the target with the correct arguments', async () => {
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const { logs } = await testContract
+                .testTransfer(false, ENCODED_REVERT, ENCODED_TRUE, to, amount)
+                .awaitTransactionSuccessAsync();
+            expect(logs).to.be.length(1);
+            verifyEventsFromLogs(logs, [{ to, amount }], TestLibERC20TokenTargetEvents.TransferCalled);
+        });
+
+        it('succeeds if the target returns true', async () => {
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            await testContract
+                .testTransfer(false, ENCODED_REVERT, ENCODED_TRUE, to, amount)
+                .awaitTransactionSuccessAsync();
+        });
+
+        it('succeeds if the target returns nothing', async () => {
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            await testContract
+                .testTransfer(false, ENCODED_REVERT, constants.NULL_BYTES, to, amount)
+                .awaitTransactionSuccessAsync();
+        });
+
+        it('fails if the target returns false', async () => {
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testTransfer(false, ENCODED_REVERT, ENCODED_FALSE, to, amount)
+                .awaitTransactionSuccessAsync();
+            const expectedError = new RawRevertError(ENCODED_FALSE);
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('fails if the target returns nonzero and not true', async () => {
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testTransfer(false, ENCODED_REVERT, ENCODED_TWO, to, amount)
+                .awaitTransactionSuccessAsync();
+            const expectedError = new RawRevertError(ENCODED_TWO);
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('fails if the target returns less than 32 bytes', async () => {
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testTransfer(false, ENCODED_REVERT, ENCODED_SHORT_TRUE, to, amount)
+                .awaitTransactionSuccessAsync();
+            const expectedError = new RawRevertError(ENCODED_SHORT_TRUE);
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('fails if the target returns greater than 32 bytes', async () => {
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testTransfer(false, ENCODED_REVERT, ENCODED_LONG_TRUE, to, amount)
+                .awaitTransactionSuccessAsync();
+            const expectedError = new RawRevertError(ENCODED_LONG_TRUE);
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('fails if the target reverts', async () => {
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testTransfer(true, ENCODED_REVERT, ENCODED_TRUE, to, amount)
+                .awaitTransactionSuccessAsync();
+            return expect(tx).to.revertWith(REVERT_STRING);
+        });
+
+        it('fails if the target reverts with no data', async () => {
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testTransfer(true, constants.NULL_BYTES, ENCODED_TRUE, to, amount)
+                .awaitTransactionSuccessAsync();
+            return expect(tx).to.be.rejectedWith('revert');
+        });
+    });
+
+    describe('transferFrom()', () => {
+        it('calls the target with the correct arguments', async () => {
+            const owner = randomAddress();
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const { logs } = await testContract
+                .testTransferFrom(false, ENCODED_REVERT, ENCODED_TRUE, owner, to, amount)
+                .awaitTransactionSuccessAsync();
+            expect(logs).to.be.length(1);
+            verifyEventsFromLogs(logs, [{ from: owner, to, amount }], TestLibERC20TokenTargetEvents.TransferFromCalled);
+        });
+
+        it('succeeds if the target returns true', async () => {
+            const owner = randomAddress();
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            await testContract
+                .testTransferFrom(false, ENCODED_REVERT, ENCODED_TRUE, owner, to, amount)
+                .awaitTransactionSuccessAsync();
+        });
+
+        it('succeeds if the target returns nothing', async () => {
+            const owner = randomAddress();
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            await testContract
+                .testTransferFrom(false, ENCODED_REVERT, constants.NULL_BYTES, owner, to, amount)
+                .awaitTransactionSuccessAsync();
+        });
+
+        it('fails if the target returns false', async () => {
+            const owner = randomAddress();
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testTransferFrom(false, ENCODED_REVERT, ENCODED_FALSE, owner, to, amount)
+                .awaitTransactionSuccessAsync();
+            const expectedError = new RawRevertError(ENCODED_FALSE);
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('fails if the target returns nonzero and not true', async () => {
+            const owner = randomAddress();
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testTransferFrom(false, ENCODED_REVERT, ENCODED_TWO, owner, to, amount)
+                .awaitTransactionSuccessAsync();
+            const expectedError = new RawRevertError(ENCODED_TWO);
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('fails if the target returns less than 32 bytes', async () => {
+            const owner = randomAddress();
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testTransferFrom(false, ENCODED_REVERT, ENCODED_SHORT_TRUE, owner, to, amount)
+                .awaitTransactionSuccessAsync();
+            const expectedError = new RawRevertError(ENCODED_SHORT_TRUE);
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('fails if the target returns greater than 32 bytes', async () => {
+            const owner = randomAddress();
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testTransferFrom(false, ENCODED_REVERT, ENCODED_LONG_TRUE, owner, to, amount)
+                .awaitTransactionSuccessAsync();
+            const expectedError = new RawRevertError(ENCODED_LONG_TRUE);
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('fails if the target reverts', async () => {
+            const owner = randomAddress();
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testTransferFrom(true, ENCODED_REVERT, ENCODED_TRUE, owner, to, amount)
+                .awaitTransactionSuccessAsync();
+            return expect(tx).to.revertWith(REVERT_STRING);
+        });
+
+        it('fails if the target reverts with no data', async () => {
+            const owner = randomAddress();
+            const to = randomAddress();
+            const amount = getRandomInteger(0, 100e18);
+            const tx = testContract
+                .testTransferFrom(true, constants.NULL_BYTES, ENCODED_TRUE, owner, to, amount)
+                .awaitTransactionSuccessAsync();
+            return expect(tx).to.be.rejectedWith('revert');
+        });
+    });
+
+    describe('decimals()', () => {
+        const DEFAULT_DECIMALS = 18;
+        const ENCODED_ZERO = hexUtils.leftPad(0);
+        const ENCODED_SHORT_ZERO = hexUtils.leftPad(0, 31);
+        const ENCODED_LONG_ZERO = hexUtils.leftPad(0, 33);
+        const randomDecimals = () => Math.floor(Math.random() * 256) + 1;
+
+        it('returns the number of decimals defined by the token', async () => {
+            const decimals = randomDecimals();
+            const encodedDecimals = hexUtils.leftPad(decimals);
+            const result = await testContract.testDecimals(false, ENCODED_REVERT, encodedDecimals).callAsync();
+            return expect(result).to.bignumber.eq(decimals);
+        });
+
+        it('returns 0 if the token returns 0', async () => {
+            const result = await testContract.testDecimals(false, ENCODED_REVERT, ENCODED_ZERO).callAsync();
+            return expect(result).to.bignumber.eq(0);
+        });
+
+        it('returns 18 if the token returns less than 32 bytes', async () => {
+            const result = await testContract.testDecimals(false, ENCODED_REVERT, ENCODED_SHORT_ZERO).callAsync();
+            return expect(result).to.bignumber.eq(DEFAULT_DECIMALS);
+        });
+
+        it('returns 18 if the token returns greater than 32 bytes', async () => {
+            const result = await testContract.testDecimals(false, ENCODED_REVERT, ENCODED_LONG_ZERO).callAsync();
+            return expect(result).to.bignumber.eq(DEFAULT_DECIMALS);
+        });
+
+        it('returns 18 if the token reverts', async () => {
+            const result = await testContract.testDecimals(true, ENCODED_REVERT, ENCODED_ZERO).callAsync();
+            return expect(result).to.bignumber.eq(DEFAULT_DECIMALS);
+        });
+    });
+});

contracts/erc20/test/unlimited_allowance_token.ts

@@ -0,0 +1,187 @@
+import { chaiSetup, constants, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
+import { BlockchainLifecycle } from '@0x/dev-utils';
+import { RevertReason } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+import * as chai from 'chai';
+
+import { DummyERC20TokenContract } from './wrappers';
+
+import { artifacts } from './artifacts';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+describe('UnlimitedAllowanceToken', () => {
+    let owner: string;
+    let spender: string;
+    const MAX_MINT_VALUE = new BigNumber(10000000000000000000000);
+    let token: DummyERC20TokenContract;
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    before(async () => {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        owner = accounts[0];
+        spender = accounts[1];
+        token = await DummyERC20TokenContract.deployFrom0xArtifactAsync(
+            artifacts.DummyERC20Token,
+            provider,
+            txDefaults,
+            artifacts,
+            constants.DUMMY_TOKEN_NAME,
+            constants.DUMMY_TOKEN_SYMBOL,
+            constants.DUMMY_TOKEN_DECIMALS,
+            constants.DUMMY_TOKEN_TOTAL_SUPPLY,
+        );
+        await web3Wrapper.awaitTransactionSuccessAsync(
+            await token.mint(MAX_MINT_VALUE).sendTransactionAsync({ from: owner }),
+            constants.AWAIT_TRANSACTION_MINED_MS,
+        );
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('transfer', () => {
+        it('should revert if owner has insufficient balance', async () => {
+            const ownerBalance = await token.balanceOf(owner).callAsync();
+            const amountToTransfer = ownerBalance.plus(1);
+            return expect(token.transfer(spender, amountToTransfer).callAsync({ from: owner })).to.revertWith(
+                RevertReason.Erc20InsufficientBalance,
+            );
+        });
+
+        it('should transfer balance from sender to receiver', async () => {
+            const receiver = spender;
+            const initOwnerBalance = await token.balanceOf(owner).callAsync();
+            const amountToTransfer = new BigNumber(1);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await token.transfer(receiver, amountToTransfer).sendTransactionAsync({ from: owner }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const finalOwnerBalance = await token.balanceOf(owner).callAsync();
+            const finalReceiverBalance = await token.balanceOf(receiver).callAsync();
+
+            const expectedFinalOwnerBalance = initOwnerBalance.minus(amountToTransfer);
+            const expectedFinalReceiverBalance = amountToTransfer;
+            expect(finalOwnerBalance).to.be.bignumber.equal(expectedFinalOwnerBalance);
+            expect(finalReceiverBalance).to.be.bignumber.equal(expectedFinalReceiverBalance);
+        });
+
+        it('should return true on a 0 value transfer', async () => {
+            const didReturnTrue = await token.transfer(spender, new BigNumber(0)).callAsync({
+                from: owner,
+            });
+            expect(didReturnTrue).to.be.true();
+        });
+    });
+
+    describe('transferFrom', () => {
+        it('should revert if owner has insufficient balance', async () => {
+            const ownerBalance = await token.balanceOf(owner).callAsync();
+            const amountToTransfer = ownerBalance.plus(1);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await token.approve(spender, amountToTransfer).sendTransactionAsync({ from: owner }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            return expect(
+                token.transferFrom(owner, spender, amountToTransfer).callAsync({
+                    from: spender,
+                }),
+            ).to.revertWith(RevertReason.Erc20InsufficientBalance);
+        });
+
+        it('should revert if spender has insufficient allowance', async () => {
+            const ownerBalance = await token.balanceOf(owner).callAsync();
+            const amountToTransfer = ownerBalance;
+
+            const spenderAllowance = await token.allowance(owner, spender).callAsync();
+            const isSpenderAllowanceInsufficient = spenderAllowance.comparedTo(amountToTransfer) < 0;
+            expect(isSpenderAllowanceInsufficient).to.be.true();
+
+            return expect(
+                token.transferFrom(owner, spender, amountToTransfer).callAsync({
+                    from: spender,
+                }),
+            ).to.revertWith(RevertReason.Erc20InsufficientAllowance);
+        });
+
+        it('should return true on a 0 value transfer', async () => {
+            const amountToTransfer = new BigNumber(0);
+            const didReturnTrue = await token.transferFrom(owner, spender, amountToTransfer).callAsync({
+                from: spender,
+            });
+            expect(didReturnTrue).to.be.true();
+        });
+
+        it('should not modify spender allowance if spender allowance is 2^256 - 1', async () => {
+            const initOwnerBalance = await token.balanceOf(owner).callAsync();
+            const amountToTransfer = initOwnerBalance;
+            const initSpenderAllowance = constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await token.approve(spender, initSpenderAllowance).sendTransactionAsync({ from: owner }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await token.transferFrom(owner, spender, amountToTransfer).sendTransactionAsync({
+                    from: spender,
+                    gas: constants.MAX_TOKEN_TRANSFERFROM_GAS,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const newSpenderAllowance = await token.allowance(owner, spender).callAsync();
+            expect(initSpenderAllowance).to.be.bignumber.equal(newSpenderAllowance);
+        });
+
+        it('should transfer the correct balances if spender has sufficient allowance', async () => {
+            const initOwnerBalance = await token.balanceOf(owner).callAsync();
+            const amountToTransfer = initOwnerBalance;
+            const initSpenderAllowance = initOwnerBalance;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await token.approve(spender, initSpenderAllowance).sendTransactionAsync({ from: owner }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await token.transferFrom(owner, spender, amountToTransfer).sendTransactionAsync({
+                    from: spender,
+                    gas: constants.MAX_TOKEN_TRANSFERFROM_GAS,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const newOwnerBalance = await token.balanceOf(owner).callAsync();
+            const newSpenderBalance = await token.balanceOf(spender).callAsync();
+
+            expect(newOwnerBalance).to.be.bignumber.equal(0);
+            expect(newSpenderBalance).to.be.bignumber.equal(initOwnerBalance);
+        });
+
+        it('should modify allowance if spender has sufficient allowance less than 2^256 - 1', async () => {
+            const initOwnerBalance = await token.balanceOf(owner).callAsync();
+            const amountToTransfer = initOwnerBalance;
+            const initSpenderAllowance = initOwnerBalance;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await token.approve(spender, initSpenderAllowance).sendTransactionAsync({ from: owner }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await token.transferFrom(owner, spender, amountToTransfer).sendTransactionAsync({
+                    from: spender,
+                    gas: constants.MAX_TOKEN_TRANSFERFROM_GAS,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const newSpenderAllowance = await token.allowance(owner, spender).callAsync();
+            expect(newSpenderAllowance).to.be.bignumber.equal(0);
+        });
+    });
+});

contracts/erc20/test/weth9.ts

@@ -0,0 +1,149 @@
+import {
+    chaiSetup,
+    constants,
+    expectInsufficientFundsAsync,
+    expectTransactionFailedWithoutReasonAsync,
+    provider,
+    txDefaults,
+    web3Wrapper,
+} from '@0x/contracts-test-utils';
+import { BlockchainLifecycle } from '@0x/dev-utils';
+import { BigNumber } from '@0x/utils';
+import { Web3Wrapper } from '@0x/web3-wrapper';
+import * as chai from 'chai';
+
+import { WETH9Contract } from './wrappers';
+
+import { artifacts } from './artifacts';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+describe('EtherToken', () => {
+    let account: string;
+    const gasPrice = new BigNumber(constants.DEFAULT_GAS_PRICE);
+    let etherToken: WETH9Contract;
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    before(async () => {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        account = accounts[0];
+
+        etherToken = await WETH9Contract.deployFrom0xArtifactAsync(
+            artifacts.WETH9,
+            provider,
+            {
+                ...txDefaults,
+                gasPrice,
+            },
+            artifacts,
+        );
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('deposit', () => {
+        it('should revert if caller attempts to deposit more Ether than caller balance', async () => {
+            const initEthBalance = await web3Wrapper.getBalanceInWeiAsync(account);
+            const ethToDeposit = initEthBalance.plus(1);
+
+            return expectInsufficientFundsAsync(etherToken.deposit().sendTransactionAsync({ value: ethToDeposit }));
+        });
+
+        it('should convert deposited Ether to wrapped Ether tokens', async () => {
+            const initEthBalance = await web3Wrapper.getBalanceInWeiAsync(account);
+            const initEthTokenBalance = await etherToken.balanceOf(account).callAsync();
+
+            const ethToDeposit = new BigNumber(Web3Wrapper.toWei(new BigNumber(1)));
+
+            const txHash = await etherToken.deposit().sendTransactionAsync({ value: ethToDeposit });
+            const receipt = await web3Wrapper.awaitTransactionSuccessAsync(
+                txHash,
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const ethSpentOnGas = gasPrice.times(receipt.gasUsed);
+            const finalEthBalance = await web3Wrapper.getBalanceInWeiAsync(account);
+            const finalEthTokenBalance = await etherToken.balanceOf(account).callAsync();
+
+            expect(finalEthBalance).to.be.bignumber.equal(initEthBalance.minus(ethToDeposit.plus(ethSpentOnGas)));
+            expect(finalEthTokenBalance).to.be.bignumber.equal(initEthTokenBalance.plus(ethToDeposit));
+        });
+    });
+
+    describe('withdraw', () => {
+        it('should revert if caller attempts to withdraw greater than caller balance', async () => {
+            const initEthTokenBalance = await etherToken.balanceOf(account).callAsync();
+            const ethTokensToWithdraw = initEthTokenBalance.plus(1);
+
+            return expectTransactionFailedWithoutReasonAsync(
+                etherToken.withdraw(ethTokensToWithdraw).sendTransactionAsync(),
+            );
+        });
+
+        it('should convert ether tokens to ether with sufficient balance', async () => {
+            const ethToDeposit = new BigNumber(Web3Wrapper.toWei(new BigNumber(1)));
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await etherToken.deposit().sendTransactionAsync({ value: ethToDeposit }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const initEthTokenBalance = await etherToken.balanceOf(account).callAsync();
+            const initEthBalance = await web3Wrapper.getBalanceInWeiAsync(account);
+            const ethTokensToWithdraw = initEthTokenBalance;
+            expect(ethTokensToWithdraw).to.not.be.bignumber.equal(0);
+            const txHash = await etherToken.withdraw(ethTokensToWithdraw).sendTransactionAsync({
+                gas: constants.MAX_ETHERTOKEN_WITHDRAW_GAS,
+            });
+            const receipt = await web3Wrapper.awaitTransactionSuccessAsync(
+                txHash,
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const ethSpentOnGas = gasPrice.times(receipt.gasUsed);
+            const finalEthBalance = await web3Wrapper.getBalanceInWeiAsync(account);
+            const finalEthTokenBalance = await etherToken.balanceOf(account).callAsync();
+
+            expect(finalEthBalance).to.be.bignumber.equal(
+                initEthBalance.plus(ethTokensToWithdraw.minus(ethSpentOnGas)),
+            );
+            expect(finalEthTokenBalance).to.be.bignumber.equal(initEthTokenBalance.minus(ethTokensToWithdraw));
+        });
+    });
+
+    describe('fallback', () => {
+        it('should convert sent ether to ether tokens', async () => {
+            const initEthBalance = await web3Wrapper.getBalanceInWeiAsync(account);
+            const initEthTokenBalance = await etherToken.balanceOf(account).callAsync();
+
+            const ethToDeposit = Web3Wrapper.toBaseUnitAmount(new BigNumber(1), 18);
+
+            const txHash = await web3Wrapper.sendTransactionAsync({
+                from: account,
+                to: etherToken.address,
+                value: ethToDeposit,
+                gasPrice,
+            });
+
+            const receipt = await web3Wrapper.awaitTransactionSuccessAsync(
+                txHash,
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const ethSpentOnGas = gasPrice.times(receipt.gasUsed);
+            const finalEthBalance = await web3Wrapper.getBalanceInWeiAsync(account);
+            const finalEthTokenBalance = await etherToken.balanceOf(account).callAsync();
+
+            expect(finalEthBalance).to.be.bignumber.equal(initEthBalance.minus(ethToDeposit.plus(ethSpentOnGas)));
+            expect(finalEthTokenBalance).to.be.bignumber.equal(initEthTokenBalance.plus(ethToDeposit));
+        });
+    });
+});

contracts/erc20/test/wrappers.ts

@@ -0,0 +1,23 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+export * from '../test/generated-wrappers/dummy_erc20_token';
+export * from '../test/generated-wrappers/dummy_multiple_return_erc20_token';
+export * from '../test/generated-wrappers/dummy_no_return_erc20_token';
+export * from '../test/generated-wrappers/erc20_token';
+export * from '../test/generated-wrappers/i_erc20_token';
+export * from '../test/generated-wrappers/i_erc20_token_v06';
+export * from '../test/generated-wrappers/i_ether_token';
+export * from '../test/generated-wrappers/i_ether_token_v06';
+export * from '../test/generated-wrappers/lib_erc20_token';
+export * from '../test/generated-wrappers/lib_erc20_token_v06';
+export * from '../test/generated-wrappers/mintable_erc20_token';
+export * from '../test/generated-wrappers/test_lib_erc20_token';
+export * from '../test/generated-wrappers/test_lib_erc20_token_target';
+export * from '../test/generated-wrappers/unlimited_allowance_erc20_token';
+export * from '../test/generated-wrappers/untransferrable_dummy_erc20_token';
+export * from '../test/generated-wrappers/weth9';
+export * from '../test/generated-wrappers/weth9v06';
+export * from '../test/generated-wrappers/zrx_token';

contracts/erc20/test/zrx_token.ts

@@ -0,0 +1,210 @@
+import { chaiSetup, constants, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
+import { BlockchainLifecycle } from '@0x/dev-utils';
+import { BigNumber } from '@0x/utils';
+import { Web3Wrapper } from '@0x/web3-wrapper';
+import * as chai from 'chai';
+
+import { ZRXTokenContract } from './wrappers';
+
+import { artifacts } from './artifacts';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+describe('ZRXToken', () => {
+    let owner: string;
+    let spender: string;
+    let MAX_UINT: BigNumber;
+    let zrxToken: ZRXTokenContract;
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    before(async () => {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        owner = accounts[0];
+        spender = accounts[1];
+        zrxToken = await ZRXTokenContract.deployFrom0xArtifactAsync(
+            artifacts.ZRXToken,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+        MAX_UINT = constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('constants', () => {
+        it('should have 18 decimals', async () => {
+            const decimals = new BigNumber(await zrxToken.decimals().callAsync());
+            const expectedDecimals = 18;
+            expect(decimals).to.be.bignumber.equal(expectedDecimals);
+        });
+
+        it('should have a total supply of 1 billion tokens', async () => {
+            const totalSupply = new BigNumber(await zrxToken.totalSupply().callAsync());
+            const expectedTotalSupply = 1000000000;
+            expect(Web3Wrapper.toUnitAmount(totalSupply, 18)).to.be.bignumber.equal(expectedTotalSupply);
+        });
+
+        it('should be named 0x Protocol Token', async () => {
+            const name = await zrxToken.name().callAsync();
+            const expectedName = '0x Protocol Token';
+            expect(name).to.be.equal(expectedName);
+        });
+
+        it('should have the symbol ZRX', async () => {
+            const symbol = await zrxToken.symbol().callAsync();
+            const expectedSymbol = 'ZRX';
+            expect(symbol).to.be.equal(expectedSymbol);
+        });
+    });
+
+    describe('constructor', () => {
+        it('should initialize owner balance to totalSupply', async () => {
+            const ownerBalance = await zrxToken.balanceOf(owner).callAsync();
+            const totalSupply = new BigNumber(await zrxToken.totalSupply().callAsync());
+            expect(totalSupply).to.be.bignumber.equal(ownerBalance);
+        });
+    });
+
+    describe('transfer', () => {
+        it('should transfer balance from sender to receiver', async () => {
+            const receiver = spender;
+            const initOwnerBalance = await zrxToken.balanceOf(owner).callAsync();
+            const amountToTransfer = new BigNumber(1);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.transfer(receiver, amountToTransfer).sendTransactionAsync({ from: owner }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const finalOwnerBalance = await zrxToken.balanceOf(owner).callAsync();
+            const finalReceiverBalance = await zrxToken.balanceOf(receiver).callAsync();
+
+            const expectedFinalOwnerBalance = initOwnerBalance.minus(amountToTransfer);
+            const expectedFinalReceiverBalance = amountToTransfer;
+            expect(finalOwnerBalance).to.be.bignumber.equal(expectedFinalOwnerBalance);
+            expect(finalReceiverBalance).to.be.bignumber.equal(expectedFinalReceiverBalance);
+        });
+
+        it('should return true on a 0 value transfer', async () => {
+            const didReturnTrue = await zrxToken.transfer(spender, new BigNumber(0)).callAsync({
+                from: owner,
+            });
+            expect(didReturnTrue).to.be.true();
+        });
+    });
+
+    describe('transferFrom', () => {
+        it('should return false if owner has insufficient balance', async () => {
+            const ownerBalance = await zrxToken.balanceOf(owner).callAsync();
+            const amountToTransfer = ownerBalance.plus(1);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.approve(spender, amountToTransfer).sendTransactionAsync({
+                    from: owner,
+                    gas: constants.MAX_TOKEN_APPROVE_GAS,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const didReturnTrue = await zrxToken.transferFrom(owner, spender, amountToTransfer).callAsync({
+                from: spender,
+            });
+            expect(didReturnTrue).to.be.false();
+        });
+
+        it('should return false if spender has insufficient allowance', async () => {
+            const ownerBalance = await zrxToken.balanceOf(owner).callAsync();
+            const amountToTransfer = ownerBalance;
+
+            const spenderAllowance = await zrxToken.allowance(owner, spender).callAsync();
+            const isSpenderAllowanceInsufficient = spenderAllowance.comparedTo(amountToTransfer) < 0;
+            expect(isSpenderAllowanceInsufficient).to.be.true();
+
+            const didReturnTrue = await zrxToken.transferFrom(owner, spender, amountToTransfer).callAsync({
+                from: spender,
+            });
+            expect(didReturnTrue).to.be.false();
+        });
+
+        it('should return true on a 0 value transfer', async () => {
+            const amountToTransfer = new BigNumber(0);
+            const didReturnTrue = await zrxToken.transferFrom(owner, spender, amountToTransfer).callAsync({
+                from: spender,
+            });
+            expect(didReturnTrue).to.be.true();
+        });
+
+        it('should not modify spender allowance if spender allowance is 2^256 - 1', async () => {
+            const initOwnerBalance = await zrxToken.balanceOf(owner).callAsync();
+            const amountToTransfer = initOwnerBalance;
+            const initSpenderAllowance = MAX_UINT;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.approve(spender, initSpenderAllowance).sendTransactionAsync({
+                    from: owner,
+                    gas: constants.MAX_TOKEN_APPROVE_GAS,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.transferFrom(owner, spender, amountToTransfer).sendTransactionAsync({
+                    from: spender,
+                    gas: constants.MAX_TOKEN_TRANSFERFROM_GAS,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const newSpenderAllowance = await zrxToken.allowance(owner, spender).callAsync();
+            expect(initSpenderAllowance).to.be.bignumber.equal(newSpenderAllowance);
+        });
+
+        it('should transfer the correct balances if spender has sufficient allowance', async () => {
+            const initOwnerBalance = await zrxToken.balanceOf(owner).callAsync();
+            const initSpenderBalance = await zrxToken.balanceOf(spender).callAsync();
+            const amountToTransfer = initOwnerBalance;
+            const initSpenderAllowance = initOwnerBalance;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.approve(spender, initSpenderAllowance).sendTransactionAsync(),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.transferFrom(owner, spender, amountToTransfer).sendTransactionAsync({
+                    from: spender,
+                    gas: constants.MAX_TOKEN_TRANSFERFROM_GAS,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const newOwnerBalance = await zrxToken.balanceOf(owner).callAsync();
+            const newSpenderBalance = await zrxToken.balanceOf(spender).callAsync();
+
+            expect(newOwnerBalance).to.be.bignumber.equal(0);
+            expect(newSpenderBalance).to.be.bignumber.equal(initSpenderBalance.plus(initOwnerBalance));
+        });
+
+        it('should modify allowance if spender has sufficient allowance less than 2^256 - 1', async () => {
+            const initOwnerBalance = await zrxToken.balanceOf(owner).callAsync();
+            const amountToTransfer = initOwnerBalance;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.approve(spender, amountToTransfer).sendTransactionAsync(),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.transferFrom(owner, spender, amountToTransfer).sendTransactionAsync({
+                    from: spender,
+                    gas: constants.MAX_TOKEN_TRANSFERFROM_GAS,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const newSpenderAllowance = await zrxToken.allowance(owner, spender).callAsync();
+            expect(newSpenderAllowance).to.be.bignumber.equal(0);
+        });
+    });
+});

contracts/erc20/truffle-config.js

@@ -0,0 +1,96 @@
+/**
+ * Use this file to configure your truffle project. It's seeded with some
+ * common settings for different networks and features like migrations,
+ * compilation and testing. Uncomment the ones you need or modify
+ * them to suit your project as necessary.
+ *
+ * More information about configuration can be found at:
+ *
+ * truffleframework.com/docs/advanced/configuration
+ *
+ * To deploy via Infura you'll need a wallet provider (like truffle-hdwallet-provider)
+ * to sign your transactions before they're sent to a remote public node. Infura accounts
+ * are available for free at: infura.io/register.
+ *
+ * You'll also need a mnemonic - the twelve word phrase the wallet uses to generate
+ * public/private key pairs. If you're publishing your code to GitHub make sure you load this
+ * phrase from a file you've .gitignored so it doesn't accidentally become public.
+ *
+ */
+
+// const HDWalletProvider = require('truffle-hdwallet-provider');
+// const infuraKey = "fj4jll3k.....";
+//
+// const fs = require('fs');
+// const mnemonic = fs.readFileSync(".secret").toString().trim();
+
+module.exports = {
+    /**
+     * Networks define how you connect to your ethereum client and let you set the
+     * defaults web3 uses to send transactions. If you don't specify one truffle
+     * will spin up a development blockchain for you on port 9545 when you
+     * run `develop` or `test`. You can ask a truffle command to use a specific
+     * network from the command line, e.g
+     *
+     * $ truffle test --network <network-name>
+     */
+
+    networks: {
+        // Useful for testing. The `development` name is special - truffle uses it by default
+        // if it's defined here and no other network is specified at the command line.
+        // You should run a client (like ganache-cli, geth or parity) in a separate terminal
+        // tab if you use this network and you must also set the `host`, `port` and `network_id`
+        // options below to some value.
+        //
+        // development: {
+        //  host: "127.0.0.1",     // Localhost (default: none)
+        //  port: 8545,            // Standard Ethereum port (default: none)
+        //  network_id: "*",       // Any network (default: none)
+        // },
+        // Another network with more advanced options...
+        // advanced: {
+        // port: 8777,             // Custom port
+        // network_id: 1342,       // Custom network
+        // gas: 8500000,           // Gas sent with each transaction (default: ~6700000)
+        // gasPrice: 20000000000,  // 20 gwei (in wei) (default: 100 gwei)
+        // from: <address>,        // Account to send txs from (default: accounts[0])
+        // websockets: true        // Enable EventEmitter interface for web3 (default: false)
+        // },
+        // Useful for deploying to a public network.
+        // NB: It's important to wrap the provider as a function.
+        // ropsten: {
+        // provider: () => new HDWalletProvider(mnemonic, `https://ropsten.infura.io/v3/YOUR-PROJECT-ID`),
+        // network_id: 3,       // Ropsten's id
+        // gas: 5500000,        // Ropsten has a lower block limit than mainnet
+        // confirmations: 2,    // # of confs to wait between deployments. (default: 0)
+        // timeoutBlocks: 200,  // # of blocks before a deployment times out  (minimum/default: 50)
+        // skipDryRun: true     // Skip dry run before migrations? (default: false for public nets )
+        // },
+        // Useful for private networks
+        // private: {
+        // provider: () => new HDWalletProvider(mnemonic, `https://network.io`),
+        // network_id: 2111,   // This network is yours, in the cloud.
+        // production: true    // Treats this network as if it was a public net. (default: false)
+        // }
+    },
+
+    // Set default mocha options here, use special reporters etc.
+    mocha: {
+        // timeout: 100000
+    },
+
+    // Configure your compilers
+    compilers: {
+        solc: {
+            version: '0.5.9',
+            settings: {
+                evmVersion: 'constantinople',
+                optimizer: {
+                    enabled: true,
+                    runs: 1000000,
+                    details: { yul: true, deduplicate: true, cse: true, constantOptimizer: true },
+                },
+            },
+        },
+    },
+};

contracts/erc20/tsconfig.json

@@ -0,0 +1,32 @@
+{
+    "extends": "../../tsconfig",
+    "compilerOptions": { "outDir": "lib", "rootDir": ".", "resolveJsonModule": true },
+    "include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*"],
+    "files": [
+        "generated-artifacts/DummyERC20Token.json",
+        "generated-artifacts/DummyMultipleReturnERC20Token.json",
+        "generated-artifacts/DummyNoReturnERC20Token.json",
+        "generated-artifacts/ERC20Token.json",
+        "generated-artifacts/WETH9.json",
+        "generated-artifacts/ZRXToken.json",
+        "test/generated-artifacts/DummyERC20Token.json",
+        "test/generated-artifacts/DummyMultipleReturnERC20Token.json",
+        "test/generated-artifacts/DummyNoReturnERC20Token.json",
+        "test/generated-artifacts/ERC20Token.json",
+        "test/generated-artifacts/IERC20Token.json",
+        "test/generated-artifacts/IERC20TokenV06.json",
+        "test/generated-artifacts/IEtherToken.json",
+        "test/generated-artifacts/IEtherTokenV06.json",
+        "test/generated-artifacts/LibERC20Token.json",
+        "test/generated-artifacts/LibERC20TokenV06.json",
+        "test/generated-artifacts/MintableERC20Token.json",
+        "test/generated-artifacts/TestLibERC20Token.json",
+        "test/generated-artifacts/TestLibERC20TokenTarget.json",
+        "test/generated-artifacts/UnlimitedAllowanceERC20Token.json",
+        "test/generated-artifacts/UntransferrableDummyERC20Token.json",
+        "test/generated-artifacts/WETH9.json",
+        "test/generated-artifacts/WETH9V06.json",
+        "test/generated-artifacts/ZRXToken.json"
+    ],
+    "exclude": ["./deploy/solc/solc_bin"]
+}

contracts/erc20/typedoc-tsconfig.json

@@ -0,0 +1,7 @@
+{
+    "extends": "../../typedoc-tsconfig",
+    "compilerOptions": {
+        "outDir": "lib"
+    },
+    "include": ["./src/**/*", "./test/**/*"]
+}

contracts/test-utils/CHANGELOG.json

@@ -1,40 +1,4 @@
 [
-    {
-        "timestamp": 1677693479,
-        "version": "5.4.48",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "timestamp": 1675210931,
-        "version": "5.4.47",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "timestamp": 1675105183,
-        "version": "5.4.46",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "timestamp": 1674517560,
-        "version": "5.4.45",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
     {
         "timestamp": 1670879498,
         "version": "5.4.44",

contracts/test-utils/CHANGELOG.md

@@ -5,22 +5,6 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
-## v5.4.48 - _March 1, 2023_
-
-    * Dependencies updated
-
-## v5.4.47 - _February 1, 2023_
-
-    * Dependencies updated
-
-## v5.4.46 - _January 30, 2023_
-
-    * Dependencies updated
-
-## v5.4.45 - _January 23, 2023_
-
-    * Dependencies updated
-
 ## v5.4.44 - _December 12, 2022_
 
     * Dependencies updated

contracts/test-utils/README.md

@@ -24,7 +24,7 @@ import {
 
 We strongly recommend that the community help us make improvements and determine the future direction of the protocol. To report bugs within this package, please create an issue in this repository.
 
-Please read our [contribution guidelines](../../.github/CONTRIBUTING.md) before getting started.
+Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.
 
 ### Install Dependencies
 

contracts/test-utils/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-test-utils",
-    "version": "5.4.48",
+    "version": "5.4.44",
     "engines": {
         "node": ">=6.12"
     },
@@ -13,11 +13,16 @@
         "build": "tsc -b",
         "build:ci": "yarn build",
         "test": "yarn run_mocha",
+        "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": "eslint src test",
         "fix": "eslint --fix src test",
-        "test:ci": "yarn 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",
+        "coverage:report:lcov": "istanbul report lcov",
+        "test:circleci": "yarn test"
     },
     "repository": {
         "type": "git",
@@ -41,10 +46,11 @@
     "dependencies": {
         "@0x/assert": "^3.0.35",
         "@0x/base-contract": "^7.0.0",
-        "@0x/contract-addresses": "^8.1.0",
+        "@0x/contract-addresses": "^8.0.0",
         "@0x/dev-utils": "^5.0.0",
         "@0x/json-schemas": "^6.4.4",
         "@0x/order-utils": "^10.4.28",
+        "@0x/sol-coverage": "^4.0.46",
         "@0x/sol-profiler": "^4.1.36",
         "@0x/sol-trace": "^3.0.46",
         "@0x/subproviders": "^7.0.0",

contracts/test-utils/src/coverage.ts

@@ -0,0 +1,26 @@
+import { devConstants } from '@0x/dev-utils';
+import { CoverageSubprovider, SolCompilerArtifactAdapter } from '@0x/sol-coverage';
+let coverageSubprovider: CoverageSubprovider;
+
+export const coverage = {
+    getCoverageSubproviderSingleton(): CoverageSubprovider {
+        if (coverageSubprovider === undefined) {
+            coverageSubprovider = coverage._getCoverageSubprovider();
+        }
+        return coverageSubprovider;
+    },
+    _getCoverageSubprovider(): CoverageSubprovider {
+        const defaultFromAddress = devConstants.TESTRPC_FIRST_ADDRESS;
+        const solCompilerArtifactAdapter = new SolCompilerArtifactAdapter();
+        const coverageSubproviderConfig = {
+            isVerbose: true,
+            ignoreFilesGlobs: ['**/node_modules/**', '**/interfaces/**', '**/test/**'],
+        };
+        const subprovider = new CoverageSubprovider(
+            solCompilerArtifactAdapter,
+            defaultFromAddress,
+            coverageSubproviderConfig,
+        );
+        return subprovider;
+    },
+};

contracts/test-utils/src/global_hooks.ts

@@ -0,0 +1,15 @@
+import { env, EnvVars } from '@0x/dev-utils';
+
+import { coverage } from './coverage';
+import { profiler } from './profiler';
+
+after('generate coverage report', async () => {
+    if (env.parseBoolean(EnvVars.SolidityCoverage)) {
+        const coverageSubprovider = coverage.getCoverageSubproviderSingleton();
+        await coverageSubprovider.writeCoverageAsync();
+    }
+    if (env.parseBoolean(EnvVars.SolidityProfiler)) {
+        const profilerSubprovider = profiler.getProfilerSubproviderSingleton();
+        await profilerSubprovider.writeProfilerOutputAsync();
+    }
+});

contracts/test-utils/src/index.ts

@@ -20,6 +20,7 @@ export { signingUtils } from './signing_utils';
 export { orderUtils } from './order_utils';
 export { typeEncodingUtils } from './type_encoding_utils';
 export { profiler } from './profiler';
+export { coverage } from './coverage';
 export { Web3ProviderEngine } from '@0x/subproviders';
 export { randomAddress } from './address_utils';
 export { OrderFactory } from './order_factory';

contracts/test-utils/src/types.ts

@@ -90,6 +90,7 @@ export enum ContractName {
     DummyERC721Token = 'DummyERC721Token',
     TestLibBytes = 'TestLibBytes',
     TestWallet = 'TestWallet',
+    Authorizable = 'Authorizable',
     Whitelist = 'Whitelist',
     Forwarder = 'Forwarder',
     BalanceThresholdFilter = 'BalanceThresholdFilter',

contracts/test-utils/src/web3_wrapper.ts

@@ -5,6 +5,7 @@ import { Web3Wrapper } from '@0x/web3-wrapper';
 import * as _ from 'lodash';
 
 import { constants } from './constants';
+import { coverage } from './coverage';
 import { profiler } from './profiler';
 import { revertTrace } from './revert_trace';
 
@@ -38,7 +39,11 @@ const enabledSubproviderCount = _.filter(
     _.identity.bind(_),
 ).length;
 if (enabledSubproviderCount > 1) {
-    throw new Error(`Only one of profiler or revert trace subproviders can be enabled at a time`);
+    throw new Error(`Only one of coverage, profiler, or revert trace subproviders can be enabled at a time`);
+}
+if (isCoverageEnabled) {
+    const coverageSubprovider = coverage.getCoverageSubproviderSingleton();
+    prependSubprovider(provider, coverageSubprovider);
 }
 if (isProfilerEnabled) {
     const profilerSubprovider = profiler.getProfilerSubproviderSingleton();

contracts/treasury/CHANGELOG.json

@@ -1,40 +1,4 @@
 [
-    {
-        "timestamp": 1677693479,
-        "version": "1.4.41",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "timestamp": 1675210931,
-        "version": "1.4.40",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "timestamp": 1675105183,
-        "version": "1.4.39",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "timestamp": 1674517560,
-        "version": "1.4.38",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
     {
         "timestamp": 1670879498,
         "version": "1.4.37",

contracts/treasury/CHANGELOG.md

@@ -5,22 +5,6 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
-## v1.4.41 - _March 1, 2023_
-
-    * Dependencies updated
-
-## v1.4.40 - _February 1, 2023_
-
-    * Dependencies updated
-
-## v1.4.39 - _January 30, 2023_
-
-    * Dependencies updated
-
-## v1.4.38 - _January 23, 2023_
-
-    * Dependencies updated
-
 ## v1.4.37 - _December 12, 2022_
 
     * Dependencies updated

contracts/treasury/README.md

@@ -16,7 +16,7 @@ We strongly recommend that the community help us make improvements and determine
 
 For proposals regarding the 0x protocol's smart contract architecture, message format, or additional functionality, go to the [0x Improvement Proposals (ZEIPs)](https://github.com/0xProject/ZEIPs) repository and follow the contribution guidelines provided therein.
 
-Please read our [contribution guidelines](../../.github/CONTRIBUTING.md) before getting started.
+Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.
 
 ### Install Dependencies
 

contracts/treasury/contracts/src/DefaultPoolOperator.sol

@@ -20,19 +20,19 @@
 pragma solidity ^0.6.12;
 pragma experimental ABIEncoderV2;
 
-import "@0x/contracts-erc20/src/IERC20Token.sol";
+import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
 import "./IStaking.sol";
 
 contract DefaultPoolOperator {
     // Immutables
     IStaking public immutable stakingProxy;
-    IERC20Token public immutable weth;
+    IERC20TokenV06 public immutable weth;
     bytes32 public immutable poolId;
 
     /// @dev Initializes this contract and creates a staking pool.
     /// @param stakingProxy_ The 0x staking proxy contract.
     /// @param weth_ The WETH token contract.
-    constructor(IStaking stakingProxy_, IERC20Token weth_) public {
+    constructor(IStaking stakingProxy_, IERC20TokenV06 weth_) public {
         stakingProxy = stakingProxy_;
         weth = weth_;
         // operator share = 100%

contracts/treasury/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-treasury",
-    "version": "1.4.41",
+    "version": "1.4.37",
     "engines": {
         "node": ">=6.12"
     },
@@ -23,7 +23,7 @@
         "generate_contract_wrappers": "abi-gen --debug --abis  ${npm_package_config_abis} --output test/generated-wrappers --backend ethers",
         "lint": "eslint src test",
         "fix": "eslint --fix src test",
-        "test:ci": "yarn test",
+        "test:circleci": "yarn test",
         "contracts:gen": "contracts-gen generate",
         "contracts:copy": "contracts-gen copy",
         "docs:md": "ts-doc-gen --sourceDir='$PROJECT_FILES' --output=$MD_FILE_DIR --fileExtension=mdx --tsconfig=./typedoc-tsconfig.json",
@@ -46,12 +46,12 @@
     "homepage": "https://github.com/0xProject/protocol/tree/main/contracts/treasury",
     "devDependencies": {
         "@0x/abi-gen": "^5.8.1",
-        "@0x/contract-addresses": "^8.1.0",
+        "@0x/contract-addresses": "^8.0.0",
         "@0x/contracts-asset-proxy": "^3.7.19",
-        "@0x/contracts-erc20": "3.3.57",
+        "@0x/contracts-erc20": "^3.3.54",
         "@0x/contracts-gen": "^2.0.48",
         "@0x/contracts-staking": "^2.0.45",
-        "@0x/contracts-test-utils": "^5.4.48",
+        "@0x/contracts-test-utils": "^5.4.44",
         "@0x/sol-compiler": "^4.8.2",
         "@0x/ts-doc-gen": "^0.0.28",
         "@types/isomorphic-fetch": "^0.0.35",
@@ -73,7 +73,7 @@
     },
     "dependencies": {
         "@0x/base-contract": "^7.0.0",
-        "@0x/protocol-utils": "^11.18.0",
+        "@0x/protocol-utils": "^11.17.3",
         "@0x/subproviders": "^7.0.0",
         "@0x/types": "^3.3.6",
         "@0x/typescript-typings": "^5.3.1",

contracts/utils/CHANGELOG.json

@@ -1,40 +1,4 @@
 [
-    {
-        "timestamp": 1677693479,
-        "version": "4.8.39",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "timestamp": 1675210931,
-        "version": "4.8.38",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "timestamp": 1675105183,
-        "version": "4.8.37",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "timestamp": 1674517560,
-        "version": "4.8.36",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
     {
         "timestamp": 1670879498,
         "version": "4.8.35",

contracts/utils/CHANGELOG.md

@@ -5,22 +5,6 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
-## v4.8.39 - _March 1, 2023_
-
-    * Dependencies updated
-
-## v4.8.38 - _February 1, 2023_
-
-    * Dependencies updated
-
-## v4.8.37 - _January 30, 2023_
-
-    * Dependencies updated
-
-## v4.8.36 - _January 23, 2023_
-
-    * Dependencies updated
-
 ## v4.8.35 - _December 12, 2022_
 
     * Dependencies updated

contracts/utils/README.md

@@ -16,7 +16,7 @@ We strongly recommend that the community help us make improvements and determine
 
 For proposals regarding the 0x protocol's smart contract architecture, message format, or additional functionality, go to the [0x Improvement Proposals (ZEIPs)](https://github.com/0xProject/ZEIPs) repository and follow the contribution guidelines provided therein.
 
-Please read our [contribution guidelines](../../.github/CONTRIBUTING.md) before getting started.
+Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.
 
 ### Install Dependencies
 

contracts/utils/contracts/src/Authorizable.sol

@@ -1,7 +1,6 @@
-// SPDX-License-Identifier: Apache-2.0
 /*
 
-  Copyright 2020 ZeroEx Intl.
+  Copyright 2019 ZeroEx Intl.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -17,43 +16,43 @@
 
 */
 
-pragma solidity ^0.8;
+pragma solidity ^0.5.9;
 
-import "./interfaces/IAuthorizableV08.sol";
-import "./errors/LibRichErrorsV08.sol";
-import "./errors/LibAuthorizableRichErrorsV08.sol";
-import "./OwnableV08.sol";
+import "./interfaces/IAuthorizable.sol";
+import "./LibAuthorizableRichErrors.sol";
+import "./LibRichErrors.sol";
+import "./Ownable.sol";
 
-contract AuthorizableV08 is OwnableV08, IAuthorizableV08 {
+contract Authorizable is Ownable, IAuthorizable {
     /// @dev Only authorized addresses can invoke functions with this modifier.
     modifier onlyAuthorized() {
         _assertSenderIsAuthorized();
         _;
     }
 
-    // @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;
-    // @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 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;
+    /// @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() OwnableV08() {}
+    constructor() public Ownable() {}
 
     /// @dev Authorizes an address.
     /// @param target Address to authorize.
-    function addAuthorizedAddress(address target) external override onlyOwner {
+    function addAuthorizedAddress(address target) external onlyOwner {
         _addAuthorizedAddress(target);
     }
 
     /// @dev Removes authorizion of an address.
     /// @param target Address to remove authorization from.
-    function removeAuthorizedAddress(address target) external override onlyOwner {
+    function removeAuthorizedAddress(address target) external onlyOwner {
         if (!authorized[target]) {
-            LibRichErrorsV08.rrevert(LibAuthorizableRichErrorsV08.TargetNotAuthorizedError(target));
+            LibRichErrors.rrevert(LibAuthorizableRichErrors.TargetNotAuthorizedError(target));
         }
         for (uint256 i = 0; i < authorities.length; i++) {
             if (authorities[i] == target) {
@@ -66,20 +65,20 @@ contract AuthorizableV08 is OwnableV08, IAuthorizableV08 {
     /// @dev Removes authorizion of an address.
     /// @param target Address to remove authorization from.
     /// @param index Index of target in authorities array.
-    function removeAuthorizedAddressAtIndex(address target, uint256 index) external override onlyOwner {
+    function removeAuthorizedAddressAtIndex(address target, uint256 index) external onlyOwner {
         _removeAuthorizedAddressAtIndex(target, index);
     }
 
     /// @dev Gets all authorized addresses.
     /// @return Array of authorized addresses.
-    function getAuthorizedAddresses() external view override returns (address[] memory) {
+    function getAuthorizedAddresses() external view returns (address[] memory) {
         return authorities;
     }
 
     /// @dev Reverts if msg.sender is not authorized.
     function _assertSenderIsAuthorized() internal view {
         if (!authorized[msg.sender]) {
-            LibRichErrorsV08.rrevert(LibAuthorizableRichErrorsV08.SenderNotAuthorizedError(msg.sender));
+            LibRichErrors.rrevert(LibAuthorizableRichErrors.SenderNotAuthorizedError(msg.sender));
         }
     }
 
@@ -88,12 +87,12 @@ contract AuthorizableV08 is OwnableV08, IAuthorizableV08 {
     function _addAuthorizedAddress(address target) internal {
         // Ensure that the target is not the zero address.
         if (target == address(0)) {
-            LibRichErrorsV08.rrevert(LibAuthorizableRichErrorsV08.ZeroCantBeAuthorizedError());
+            LibRichErrors.rrevert(LibAuthorizableRichErrors.ZeroCantBeAuthorizedError());
         }
 
         // Ensure that the target is not already authorized.
         if (authorized[target]) {
-            LibRichErrorsV08.rrevert(LibAuthorizableRichErrorsV08.TargetAlreadyAuthorizedError(target));
+            LibRichErrors.rrevert(LibAuthorizableRichErrors.TargetAlreadyAuthorizedError(target));
         }
 
         authorized[target] = true;
@@ -106,20 +105,18 @@ contract AuthorizableV08 is OwnableV08, IAuthorizableV08 {
     /// @param index Index of target in authorities array.
     function _removeAuthorizedAddressAtIndex(address target, uint256 index) internal {
         if (!authorized[target]) {
-            LibRichErrorsV08.rrevert(LibAuthorizableRichErrorsV08.TargetNotAuthorizedError(target));
+            LibRichErrors.rrevert(LibAuthorizableRichErrors.TargetNotAuthorizedError(target));
         }
         if (index >= authorities.length) {
-            LibRichErrorsV08.rrevert(LibAuthorizableRichErrorsV08.IndexOutOfBoundsError(index, authorities.length));
+            LibRichErrors.rrevert(LibAuthorizableRichErrors.IndexOutOfBoundsError(index, authorities.length));
         }
         if (authorities[index] != target) {
-            LibRichErrorsV08.rrevert(
-                LibAuthorizableRichErrorsV08.AuthorizedAddressMismatchError(authorities[index], target)
-            );
+            LibRichErrors.rrevert(LibAuthorizableRichErrors.AuthorizedAddressMismatchError(authorities[index], target));
         }
 
         delete authorized[target];
         authorities[index] = authorities[authorities.length - 1];
-        authorities.pop();
+        authorities.length -= 1;
         emit AuthorizedAddressRemoved(target, msg.sender);
     }
 }

contracts/utils/contracts/src/D18.sol

@@ -0,0 +1,159 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+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);
+    /// @dev Minimum signed integer value.
+    int256 private constant MIN_INT256_VALUE =
+        int256(0x8000000000000000000000000000000000000000000000000000000000000000);
+
+    /// @dev Return `1.0`
+    function one() internal pure returns (int256 r) {
+        r = DECIMAL_ONE;
+    }
+
+    /// @dev Add two decimals.
+    function add(int256 a, int256 b) internal pure returns (int256 r) {
+        r = _add(a, b);
+    }
+
+    /// @dev Add two decimals.
+    function add(uint256 a, int256 b) 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) 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) 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) internal pure returns (int256 r) {
+        r = _add(a, -b);
+    }
+
+    /// @dev Subract two decimals.
+    function sub(uint256 a, int256 b) 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) 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) internal pure returns (int256 r) {
+        r = _div(_mul(a, b), DECIMAL_ONE);
+    }
+
+    /// @dev Multiply two decimals.
+    function mul(uint256 a, int256 b) 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) 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) 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) internal pure returns (int256 r) {
+        r = _div(_mul(a, DECIMAL_ONE), b);
+    }
+
+    /// @dev Divide two decimals.
+    function div(uint256 a, int256 b) 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) 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) 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) 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) internal pure returns (int256 r) {
+        r = a < 0 ? 0 : a;
+    }
+
+    /// @dev Safely multiply two signed integers.
+    function _mul(int256 a, int256 b) private pure returns (int256 r) {
+        if (a == 0 || b == 0) {
+            return 0;
+        }
+        r = a * b;
+        require(r / a == b && r / b == a, "D18/DECIMAL_MUL_OVERFLOW");
+        return r;
+    }
+
+    /// @dev Safely divide two signed integers.
+    function _div(int256 a, int256 b) 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) private pure returns (int256 r) {
+        r = a + b;
+        require(!((a < 0 && b < 0 && r > a) || (a > 0 && b > 0 && r < a)), "D18/DECIMAL_ADD_OVERFLOW");
+    }
+}

contracts/utils/contracts/src/DeploymentConstants.sol

@@ -0,0 +1,251 @@
+/*
+
+  Copyright 2020 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+contract DeploymentConstants {
+    // Mainnet addresses ///////////////////////////////////////////////////////
+    /// @dev Mainnet address of the WETH contract.
+    address private constant WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+    /// @dev Mainnet address of the KyberNetworkProxy contract.
+    address private constant KYBER_NETWORK_PROXY_ADDRESS = 0x9AAb3f75489902f3a48495025729a0AF77d4b11e;
+    /// @dev Mainnet address of the KyberHintHandler contract.
+    address private constant KYBER_HINT_HANDLER_ADDRESS = 0xa1C0Fa73c39CFBcC11ec9Eb1Afc665aba9996E2C;
+    /// @dev Mainnet address of the `UniswapExchangeFactory` contract.
+    address private constant UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95;
+    /// @dev Mainnet address of the `UniswapV2Router01` contract.
+    address private constant UNISWAP_V2_ROUTER_01_ADDRESS = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a;
+    /// @dev Mainnet address of the Eth2Dai `MatchingMarket` contract.
+    address private constant ETH2DAI_ADDRESS = 0x794e6e91555438aFc3ccF1c5076A74F42133d08D;
+    /// @dev Mainnet address of the `ERC20BridgeProxy` contract
+    address private constant ERC20_BRIDGE_PROXY_ADDRESS = 0x8ED95d1746bf1E4dAb58d8ED4724f1Ef95B20Db0;
+    ///@dev Mainnet address of the `Dai` (multi-collateral) contract
+    address private constant DAI_ADDRESS = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
+    /// @dev Mainnet address of the `Chai` contract
+    address private constant CHAI_ADDRESS = 0x06AF07097C9Eeb7fD685c692751D5C66dB49c215;
+    /// @dev Mainnet address of the 0x DevUtils contract.
+    address private constant DEV_UTILS_ADDRESS = 0x74134CF88b21383713E096a5ecF59e297dc7f547;
+    /// @dev Kyber ETH pseudo-address.
+    address internal constant KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+    /// @dev Mainnet address of the dYdX contract.
+    address private constant DYDX_ADDRESS = 0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e;
+    /// @dev Mainnet address of the GST2 contract
+    address private constant GST_ADDRESS = 0x0000000000b3F879cb30FE243b4Dfee438691c04;
+    /// @dev Mainnet address of the GST Collector
+    address private constant GST_COLLECTOR_ADDRESS = 0x000000D3b08566BE75A6DB803C03C85C0c1c5B96;
+    /// @dev Mainnet address of the mStable mUSD contract.
+    address private constant MUSD_ADDRESS = 0xe2f2a5C287993345a840Db3B0845fbC70f5935a5;
+    /// @dev Mainnet address of the Mooniswap Registry contract
+    address private constant MOONISWAP_REGISTRY = 0x71CD6666064C3A1354a3B4dca5fA1E2D3ee7D303;
+    /// @dev Mainnet address of the DODO Registry (ZOO) contract
+    address private constant DODO_REGISTRY = 0x3A97247DF274a17C59A3bd12735ea3FcDFb49950;
+    /// @dev Mainnet address of the DODO Helper contract
+    address private constant DODO_HELPER = 0x533dA777aeDCE766CEAe696bf90f8541A4bA80Eb;
+
+    // // Ropsten addresses ///////////////////////////////////////////////////////
+    /// @dev Mainnet address of the WETH contract.
+    // address constant private WETH_ADDRESS = 0xc778417E063141139Fce010982780140Aa0cD5Ab;
+    /// @dev Mainnet address of the KyberNetworkProxy contract.
+    // address constant private KYBER_NETWORK_PROXY_ADDRESS = 0xd719c34261e099Fdb33030ac8909d5788D3039C4;
+    /// @dev Mainnet address of the `UniswapExchangeFactory` contract.
+    // address constant private UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0x9c83dCE8CA20E9aAF9D3efc003b2ea62aBC08351;
+    /// @dev Mainnet address of the `UniswapV2Router01` contract.
+    // address constant private UNISWAP_V2_ROUTER_01_ADDRESS = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a;
+    /// @dev Mainnet address of the Eth2Dai `MatchingMarket` contract.
+    // address constant private ETH2DAI_ADDRESS = address(0);
+    /// @dev Mainnet address of the `ERC20BridgeProxy` contract
+    // address constant private ERC20_BRIDGE_PROXY_ADDRESS = 0xb344afeD348de15eb4a9e180205A2B0739628339;
+    // ///@dev Mainnet address of the `Dai` (multi-collateral) contract
+    // address constant private DAI_ADDRESS = address(0);
+    /// @dev Mainnet address of the `Chai` contract
+    // address constant private CHAI_ADDRESS = address(0);
+    /// @dev Mainnet address of the 0x DevUtils contract.
+    // address constant private DEV_UTILS_ADDRESS = 0xC812AF3f3fBC62F76ea4262576EC0f49dB8B7f1c;
+    /// @dev Kyber ETH pseudo-address.
+    // address constant internal KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+    /// @dev Mainnet address of the dYdX contract.
+    // address constant private DYDX_ADDRESS = address(0);
+    /// @dev Mainnet address of the GST2 contract
+    // address constant private GST_ADDRESS = address(0);
+    /// @dev Mainnet address of the GST Collector
+    // address constant private GST_COLLECTOR_ADDRESS = address(0);
+    /// @dev Mainnet address of the mStable mUSD contract.
+    // address constant private MUSD_ADDRESS = 0x4E1000616990D83e56f4b5fC6CC8602DcfD20459;
+
+    // // Rinkeby addresses ///////////////////////////////////////////////////////
+    /// @dev Mainnet address of the WETH contract.
+    // address constant private WETH_ADDRESS = 0xc778417E063141139Fce010982780140Aa0cD5Ab;
+    /// @dev Mainnet address of the KyberNetworkProxy contract.
+    // address constant private KYBER_NETWORK_PROXY_ADDRESS = 0x0d5371e5EE23dec7DF251A8957279629aa79E9C5;
+    /// @dev Mainnet address of the `UniswapExchangeFactory` contract.
+    // address constant private UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0xf5D915570BC477f9B8D6C0E980aA81757A3AaC36;
+    /// @dev Mainnet address of the `UniswapV2Router01` contract.
+    // address constant private UNISWAP_V2_ROUTER_01_ADDRESS = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a;
+    /// @dev Mainnet address of the Eth2Dai `MatchingMarket` contract.
+    // address constant private ETH2DAI_ADDRESS = address(0);
+    /// @dev Mainnet address of the `ERC20BridgeProxy` contract
+    // address constant private ERC20_BRIDGE_PROXY_ADDRESS = 0xA2AA4bEFED748Fba27a3bE7Dfd2C4b2c6DB1F49B;
+    // ///@dev Mainnet address of the `Dai` (multi-collateral) contract
+    // address constant private DAI_ADDRESS = address(0);
+    /// @dev Mainnet address of the `Chai` contract
+    // address constant private CHAI_ADDRESS = address(0);
+    /// @dev Mainnet address of the 0x DevUtils contract.
+    // address constant private DEV_UTILS_ADDRESS = 0x46B5BC959e8A754c0256FFF73bF34A52Ad5CdfA9;
+    /// @dev Kyber ETH pseudo-address.
+    // address constant internal KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+    /// @dev Mainnet address of the dYdX contract.
+    // address constant private DYDX_ADDRESS = address(0);
+    /// @dev Mainnet address of the GST2 contract
+    // address constant private GST_ADDRESS = address(0);
+    /// @dev Mainnet address of the GST Collector
+    // address constant private GST_COLLECTOR_ADDRESS = address(0);
+    /// @dev Mainnet address of the mStable mUSD contract.
+    // address constant private MUSD_ADDRESS = address(0);
+
+    // // Kovan addresses /////////////////////////////////////////////////////////
+    /// @dev Kovan address of the WETH contract.
+    // address constant private WETH_ADDRESS = 0xd0A1E359811322d97991E03f863a0C30C2cF029C;
+    /// @dev Kovan address of the KyberNetworkProxy contract.
+    // address constant private KYBER_NETWORK_PROXY_ADDRESS = 0x692f391bCc85cefCe8C237C01e1f636BbD70EA4D;
+    /// @dev Kovan address of the `UniswapExchangeFactory` contract.
+    // address constant private UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0xD3E51Ef092B2845f10401a0159B2B96e8B6c3D30;
+    /// @dev Kovan address of the `UniswapV2Router01` contract.
+    // address constant private UNISWAP_V2_ROUTER_01_ADDRESS = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a;
+    /// @dev Kovan address of the Eth2Dai `MatchingMarket` contract.
+    // address constant private ETH2DAI_ADDRESS = 0xe325acB9765b02b8b418199bf9650972299235F4;
+    /// @dev Kovan address of the `ERC20BridgeProxy` contract
+    // address constant private ERC20_BRIDGE_PROXY_ADDRESS = 0x3577552C1Fb7A44aD76BeEB7aB53251668A21F8D;
+    /// @dev Kovan address of the `Chai` contract
+    // address constant private CHAI_ADDRESS = address(0);
+    /// @dev Kovan address of the `Dai` (multi-collateral) contract
+    // address constant private DAI_ADDRESS = 0x4F96Fe3b7A6Cf9725f59d353F723c1bDb64CA6Aa;
+    /// @dev Kovan address of the 0x DevUtils contract.
+    // address constant private DEV_UTILS_ADDRESS = 0x9402639A828BdF4E9e4103ac3B69E1a6E522eB59;
+    /// @dev Kyber ETH pseudo-address.
+    // address constant internal KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+    /// @dev Kovan address of the dYdX contract.
+    // address constant private DYDX_ADDRESS = address(0);
+    /// @dev Kovan address of the GST2 contract
+    // address constant private GST_ADDRESS = address(0);
+    /// @dev Kovan address of the GST Collector
+    // address constant private GST_COLLECTOR_ADDRESS = address(0);
+    /// @dev Mainnet address of the mStable mUSD contract.
+    // address constant private MUSD_ADDRESS = address(0);
+
+    /// @dev Overridable way to get the `KyberNetworkProxy` address.
+    /// @return kyberAddress The `IKyberNetworkProxy` address.
+    function _getKyberNetworkProxyAddress() 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() 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() internal view returns (address wethAddress) {
+        return WETH_ADDRESS;
+    }
+
+    /// @dev Overridable way to get the `UniswapExchangeFactory` address.
+    /// @return uniswapAddress The `UniswapExchangeFactory` address.
+    function _getUniswapExchangeFactoryAddress() 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() 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() internal view returns (address eth2daiAddress) {
+        return ETH2DAI_ADDRESS;
+    }
+
+    /// @dev An overridable way to retrieve the `ERC20BridgeProxy` contract.
+    /// @return erc20BridgeProxyAddress The `ERC20BridgeProxy` contract.
+    function _getERC20BridgeProxyAddress() 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() internal view returns (address daiAddress) {
+        return DAI_ADDRESS;
+    }
+
+    /// @dev An overridable way to retrieve the `Chai` contract.
+    /// @return chaiAddress The `Chai` contract.
+    function _getChaiAddress() 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() 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() 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() 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() 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() 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() 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() 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() internal view returns (address) {
+        return DODO_HELPER;
+    }
+}

contracts/utils/contracts/src/LibAddress.sol

@@ -0,0 +1,46 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+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,
+     * as the code is not actually created until after the constructor finishes.
+     * @param account address of the account to check
+     * @return whether the target address is a contract
+     */
+    function isContract(address account) internal view returns (bool) {
+        uint256 size;
+        // XXX Currently there is no better way to check if there is a contract in an address
+        // than to check the size of the code at that address.
+        // See https://ethereum.stackexchange.com/a/14016/36603
+        // for more details about how this works.
+        // TODO Check this again before the Serenity release, because all addresses will be
+        // contracts then.
+        // solium-disable-next-line security/no-inline-assembly
+        assembly {
+            size := extcodesize(account)
+        }
+        return size > 0;
+    }
+}

contracts/utils/contracts/src/LibAddressArray.sol

@@ -0,0 +1,153 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+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
+    ///      memory location of `addressArray`.
+    /// @param addressArray Array of addresses.
+    /// @param addressToAppend  Address to append.
+    /// @return Array of addresses: [... addressArray, addressToAppend]
+    function append(address[] memory addressArray, address addressToAppend) internal pure returns (address[] memory) {
+        // Get stats on address array and free memory
+        uint256 freeMemPtr = 0;
+        uint256 addressArrayBeginPtr = 0;
+        uint256 addressArrayEndPtr = 0;
+        uint256 addressArrayLength = addressArray.length;
+        uint256 addressArrayMemSizeInBytes = 32 + (32 * addressArrayLength);
+        assembly {
+            freeMemPtr := mload(0x40)
+            addressArrayBeginPtr := addressArray
+            addressArrayEndPtr := add(addressArray, addressArrayMemSizeInBytes)
+        }
+
+        // Cases for `freeMemPtr`:
+        //  `freeMemPtr` == `addressArrayEndPtr`: Nothing occupies memory after `addressArray`
+        //  `freeMemPtr` > `addressArrayEndPtr`: Some value occupies memory after `addressArray`
+        //  `freeMemPtr` < `addressArrayEndPtr`: Memory has not been managed properly.
+        if (freeMemPtr < addressArrayEndPtr) {
+            LibRichErrors.rrevert(LibAddressArrayRichErrors.MismanagedMemoryError(freeMemPtr, addressArrayEndPtr));
+        }
+
+        // If free memory begins at the end of `addressArray`
+        // then we can append `addressToAppend` directly.
+        // Otherwise, we must copy the array to free memory
+        // before appending new values to it.
+        if (freeMemPtr > addressArrayEndPtr) {
+            LibBytes.memCopy(freeMemPtr, addressArrayBeginPtr, addressArrayMemSizeInBytes);
+            assembly {
+                addressArray := freeMemPtr
+                addressArrayBeginPtr := addressArray
+            }
+        }
+
+        // Append `addressToAppend`
+        addressArrayLength += 1;
+        addressArrayMemSizeInBytes += 32;
+        addressArrayEndPtr = addressArrayBeginPtr + addressArrayMemSizeInBytes;
+        freeMemPtr = addressArrayEndPtr;
+        assembly {
+            // Store new array length
+            mstore(addressArray, addressArrayLength)
+
+            // Update `freeMemPtr`
+            mstore(0x40, freeMemPtr)
+        }
+        addressArray[addressArrayLength - 1] = addressToAppend;
+        return addressArray;
+    }
+
+    /// @dev Checks if an address array contains the target address.
+    /// @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) internal pure returns (bool success) {
+        assembly {
+            // Calculate byte length of array
+            let arrayByteLen := mul(mload(addressArray), 32)
+            // Calculate beginning of array contents
+            let arrayContentsStart := add(addressArray, 32)
+            // Calclulate end of array contents
+            let arrayContentsEnd := add(arrayContentsStart, arrayByteLen)
+
+            // Loop through array
+            for {
+                let i := arrayContentsStart
+            } lt(i, arrayContentsEnd) {
+                i := add(i, 32)
+            } {
+                // Load array element
+                let arrayElement := mload(i)
+
+                // Return true if array element equals target
+                if eq(target, arrayElement) {
+                    // Set success to true
+                    success := 1
+                    // Break loop
+                    i := arrayContentsEnd
+                }
+            }
+        }
+        return success;
+    }
+
+    /// @dev Finds the index of an address within an array.
+    /// @param addressArray Array of addresses.
+    /// @param target Address to search for in array.
+    /// @return Existence and index of the target in the array.
+    function indexOf(
+        address[] memory addressArray,
+        address target
+    ) internal pure returns (bool success, uint256 index) {
+        assembly {
+            // Calculate byte length of array
+            let arrayByteLen := mul(mload(addressArray), 32)
+            // Calculate beginning of array contents
+            let arrayContentsStart := add(addressArray, 32)
+            // Calclulate end of array contents
+            let arrayContentsEnd := add(arrayContentsStart, arrayByteLen)
+
+            // Loop through array
+            for {
+                let i := arrayContentsStart
+            } lt(i, arrayContentsEnd) {
+                i := add(i, 32)
+            } {
+                // Load array element
+                let arrayElement := mload(i)
+
+                // Return true if array element equals target
+                if eq(target, arrayElement) {
+                    // Set success and index
+                    success := 1
+                    index := div(sub(i, arrayContentsStart), 32)
+                    // Break loop
+                    i := arrayContentsEnd
+                }
+            }
+        }
+        return (success, index);
+    }
+}

contracts/utils/contracts/src/LibAddressArrayRichErrors.sol

@@ -0,0 +1,31 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+library LibAddressArrayRichErrors {
+    // bytes4(keccak256("MismanagedMemoryError(uint256,uint256)"))
+    bytes4 internal constant MISMANAGED_MEMORY_ERROR_SELECTOR = 0x5fc83722;
+
+    function MismanagedMemoryError(
+        uint256 freeMemPtr,
+        uint256 addressArrayEndPtr
+    ) internal pure returns (bytes memory) {
+        return abi.encodeWithSelector(MISMANAGED_MEMORY_ERROR_SELECTOR, freeMemPtr, addressArrayEndPtr);
+    }
+}

contracts/utils/contracts/src/LibAuthorizableRichErrors.sol

@@ -1,7 +1,6 @@
-// SPDX-License-Identifier: Apache-2.0
 /*
 
-  Copyright 2020 ZeroEx Intl.
+  Copyright 2019 ZeroEx Intl.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -17,9 +16,9 @@
 
 */
 
-pragma solidity ^0.8;
+pragma solidity ^0.5.9;
 
-library LibAuthorizableRichErrorsV08 {
+library LibAuthorizableRichErrors {
     // bytes4(keccak256("AuthorizedAddressMismatchError(address,address)"))
     bytes4 internal constant AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR = 0x140a84db;
 

contracts/utils/contracts/src/LibEIP1271.sol

@@ -0,0 +1,25 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+contract LibEIP1271 {
+    /// @dev Magic bytes returned by EIP1271 wallets on success.
+    /// @return 0 Magic bytes.
+    bytes4 public constant EIP1271_MAGIC_VALUE = 0x20c13b0b;
+}

contracts/utils/contracts/src/LibEIP712.sol

@@ -0,0 +1,103 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+library LibEIP712 {
+    // Hash of the EIP712 Domain Separator Schema
+    // keccak256(abi.encodePacked(
+    //     "EIP712Domain(",
+    //     "string name,",
+    //     "string version,",
+    //     "uint256 chainId,",
+    //     "address verifyingContract",
+    //     ")"
+    // ))
+    bytes32 internal constant _EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH =
+        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
+
+    /// @dev Calculates a EIP712 domain separator.
+    /// @param name The EIP712 domain name.
+    /// @param version The EIP712 domain version.
+    /// @param verifyingContract The EIP712 verifying contract.
+    /// @return EIP712 domain separator.
+    function hashEIP712Domain(
+        string memory name,
+        string memory version,
+        uint256 chainId,
+        address verifyingContract
+    ) internal pure returns (bytes32 result) {
+        bytes32 schemaHash = _EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH;
+
+        // Assembly for more efficient computing:
+        // keccak256(abi.encodePacked(
+        //     _EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
+        //     keccak256(bytes(name)),
+        //     keccak256(bytes(version)),
+        //     chainId,
+        //     uint256(verifyingContract)
+        // ))
+
+        assembly {
+            // Calculate hashes of dynamic data
+            let nameHash := keccak256(add(name, 32), mload(name))
+            let versionHash := keccak256(add(version, 32), mload(version))
+
+            // Load free memory pointer
+            let memPtr := mload(64)
+
+            // Store params in memory
+            mstore(memPtr, schemaHash)
+            mstore(add(memPtr, 32), nameHash)
+            mstore(add(memPtr, 64), versionHash)
+            mstore(add(memPtr, 96), chainId)
+            mstore(add(memPtr, 128), verifyingContract)
+
+            // Compute hash
+            result := keccak256(memPtr, 160)
+        }
+        return result;
+    }
+
+    /// @dev Calculates EIP712 encoding for a hash struct with a given domain hash.
+    /// @param eip712DomainHash Hash of the domain domain separator data, computed
+    ///                         with getDomainHash().
+    /// @param hashStruct The EIP712 hash struct.
+    /// @return EIP712 hash applied to the given EIP712 Domain.
+    function hashEIP712Message(bytes32 eip712DomainHash, bytes32 hashStruct) internal pure returns (bytes32 result) {
+        // Assembly for more efficient computing:
+        // keccak256(abi.encodePacked(
+        //     EIP191_HEADER,
+        //     EIP712_DOMAIN_HASH,
+        //     hashStruct
+        // ));
+
+        assembly {
+            // Load free memory pointer
+            let memPtr := mload(64)
+
+            mstore(memPtr, 0x1901000000000000000000000000000000000000000000000000000000000000) // EIP191 header
+            mstore(add(memPtr, 2), eip712DomainHash) // EIP712 domain hash
+            mstore(add(memPtr, 34), hashStruct) // Hash of struct
+
+            // Compute hash
+            result := keccak256(memPtr, 66)
+        }
+        return result;
+    }
+}

contracts/utils/contracts/src/LibFractions.sol

@@ -0,0 +1,96 @@
+pragma solidity ^0.5.9;
+
+import "./LibSafeMath.sol";
+
+library LibFractions {
+    using LibSafeMath for uint256;
+
+    /// @dev Safely adds two fractions `n1/d1 + n2/d2`
+    /// @param n1 numerator of `1`
+    /// @param d1 denominator of `1`
+    /// @param n2 numerator of `2`
+    /// @param d2 denominator of `2`
+    /// @return numerator Numerator of sum
+    /// @return denominator Denominator of sum
+    function add(
+        uint256 n1,
+        uint256 d1,
+        uint256 n2,
+        uint256 d2
+    ) 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.safeMul(d2).safeAdd(n2.safeMul(d1));
+        denominator = d1.safeMul(d2);
+        return (numerator, denominator);
+    }
+
+    /// @dev Rescales a fraction to prevent overflows during addition if either
+    ///      the numerator or the denominator are > `maxValue`.
+    /// @param numerator The numerator.
+    /// @param denominator The denominator.
+    /// @param maxValue The maximum value allowed for both the numerator and
+    ///        denominator.
+    /// @return scaledNumerator The rescaled numerator.
+    /// @return scaledDenominator The rescaled denominator.
+    function normalize(
+        uint256 numerator,
+        uint256 denominator,
+        uint256 maxValue
+    ) 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) {
+            uint256 rescaleBase = numerator >= denominator ? numerator : denominator;
+            rescaleBase = rescaleBase.safeDiv(maxValue);
+            scaledNumerator = numerator.safeDiv(rescaleBase);
+            scaledDenominator = denominator.safeDiv(rescaleBase);
+        } else {
+            scaledNumerator = numerator;
+            scaledDenominator = denominator;
+        }
+        return (scaledNumerator, scaledDenominator);
+    }
+
+    /// @dev Rescales a fraction to prevent overflows during addition if either
+    ///      the numerator or the denominator are > 2 ** 127.
+    /// @param numerator The numerator.
+    /// @param denominator The denominator.
+    /// @return scaledNumerator The rescaled numerator.
+    /// @return scaledDenominator The rescaled denominator.
+    function normalize(
+        uint256 numerator,
+        uint256 denominator
+    ) internal pure returns (uint256 scaledNumerator, uint256 scaledDenominator) {
+        return normalize(numerator, denominator, 2 ** 127);
+    }
+
+    /// @dev Safely scales the difference between two fractions.
+    /// @param n1 numerator of `1`
+    /// @param d1 denominator of `1`
+    /// @param n2 numerator of `2`
+    /// @param d2 denominator of `2`
+    /// @param s scalar to multiply by difference.
+    /// @return result `s * (n1/d1 - n2/d2)`.
+    function scaleDifference(
+        uint256 n1,
+        uint256 d1,
+        uint256 n2,
+        uint256 d2,
+        uint256 s
+    ) internal pure returns (uint256 result) {
+        if (s == 0) {
+            return 0;
+        }
+        if (n2 == 0) {
+            return result = s.safeMul(n1).safeDiv(d1);
+        }
+        uint256 numerator = n1.safeMul(d2).safeSub(n2.safeMul(d1));
+        uint256 tmp = numerator.safeDiv(d2);
+        return s.safeMul(tmp).safeDiv(d1);
+    }
+}

contracts/utils/contracts/src/LibMath.sol

@@ -1,4 +1,3 @@
-// SPDX-License-Identifier: Apache-2.0
 /*
 
   Copyright 2019 ZeroEx Intl.
@@ -17,57 +16,31 @@
 
 */
 
-pragma solidity ^0.8;
+pragma solidity ^0.5.9;
 
-import "./errors/LibRichErrorsV08.sol";
-import "./errors/LibMathRichErrorsV08.sol";
-import "./errors/LibSafeMathRichErrorsV08.sol";
+import "./LibSafeMath.sol";
+import "./LibRichErrors.sol";
+import "./LibMathRichErrors.sol";
 
-library LibMathV08 {
-    function max256(uint256 a, uint256 b) internal pure returns (uint256) {
-        return a >= b ? a : b;
-    }
-
-    function min256(uint256 a, uint256 b) internal pure returns (uint256) {
-        return a < b ? a : b;
-    }
-
-    function max128(uint128 a, uint128 b) internal pure returns (uint128) {
-        return a >= b ? a : b;
-    }
-
-    function min128(uint128 a, uint128 b) internal pure returns (uint128) {
-        return a < b ? a : b;
-    }
-
-    function safeDowncastToUint128(uint256 a) internal pure returns (uint128) {
-        if (a > type(uint128).max) {
-            LibRichErrorsV08.rrevert(
-                LibSafeMathRichErrorsV08.Uint256DowncastError(
-                    LibSafeMathRichErrorsV08.DowncastErrorCodes.VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT128,
-                    a
-                )
-            );
-        }
-        return uint128(a);
-    }
+library LibMath {
+    using LibSafeMath for uint256;
 
     /// @dev Calculates partial value given a numerator and denominator rounded down.
     ///      Reverts if rounding error is >= 0.1%
     /// @param numerator Numerator.
     /// @param denominator Denominator.
     /// @param target Value to calculate partial of.
-    /// @return partialAmount Partial value of target rounded down.
+    /// @return Partial value of target rounded down.
     function safeGetPartialAmountFloor(
         uint256 numerator,
         uint256 denominator,
         uint256 target
     ) internal pure returns (uint256 partialAmount) {
         if (isRoundingErrorFloor(numerator, denominator, target)) {
-            LibRichErrorsV08.rrevert(LibMathRichErrorsV08.RoundingError(numerator, denominator, target));
+            LibRichErrors.rrevert(LibMathRichErrors.RoundingError(numerator, denominator, target));
         }
 
-        partialAmount = (numerator * target) / denominator;
+        partialAmount = numerator.safeMul(target).safeDiv(denominator);
         return partialAmount;
     }
 
@@ -76,20 +49,20 @@ library LibMathV08 {
     /// @param numerator Numerator.
     /// @param denominator Denominator.
     /// @param target Value to calculate partial of.
-    /// @return partialAmount Partial value of target rounded up.
+    /// @return Partial value of target rounded up.
     function safeGetPartialAmountCeil(
         uint256 numerator,
         uint256 denominator,
         uint256 target
     ) internal pure returns (uint256 partialAmount) {
         if (isRoundingErrorCeil(numerator, denominator, target)) {
-            LibRichErrorsV08.rrevert(LibMathRichErrorsV08.RoundingError(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 * target + (denominator - 1)) / denominator;
+        partialAmount = numerator.safeMul(target).safeAdd(denominator.safeSub(1)).safeDiv(denominator);
 
         return partialAmount;
     }
@@ -98,13 +71,13 @@ library LibMathV08 {
     /// @param numerator Numerator.
     /// @param denominator Denominator.
     /// @param target Value to calculate partial of.
-    /// @return partialAmount Partial value of target rounded down.
+    /// @return Partial value of target rounded down.
     function getPartialAmountFloor(
         uint256 numerator,
         uint256 denominator,
         uint256 target
     ) internal pure returns (uint256 partialAmount) {
-        partialAmount = (numerator * target) / denominator;
+        partialAmount = numerator.safeMul(target).safeDiv(denominator);
         return partialAmount;
     }
 
@@ -112,7 +85,7 @@ library LibMathV08 {
     /// @param numerator Numerator.
     /// @param denominator Denominator.
     /// @param target Value to calculate partial of.
-    /// @return partialAmount Partial value of target rounded up.
+    /// @return Partial value of target rounded up.
     function getPartialAmountCeil(
         uint256 numerator,
         uint256 denominator,
@@ -121,7 +94,7 @@ library LibMathV08 {
         // 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 * target + (denominator - 1)) / denominator;
+        partialAmount = numerator.safeMul(target).safeAdd(denominator.safeSub(1)).safeDiv(denominator);
 
         return partialAmount;
     }
@@ -130,14 +103,14 @@ library LibMathV08 {
     /// @param numerator Numerator.
     /// @param denominator Denominator.
     /// @param target Value to multiply with numerator/denominator.
-    /// @return isError Rounding error is present.
+    /// @return Rounding error is present.
     function isRoundingErrorFloor(
         uint256 numerator,
         uint256 denominator,
         uint256 target
     ) internal pure returns (bool isError) {
         if (denominator == 0) {
-            LibRichErrorsV08.rrevert(LibMathRichErrorsV08.DivisionByZeroError());
+            LibRichErrors.rrevert(LibMathRichErrors.DivisionByZeroError());
         }
 
         // The absolute rounding error is the difference between the rounded
@@ -167,7 +140,7 @@ library LibMathV08 {
         // so we have a rounding error iff:
         //        1000 * remainder  >=  numerator * target
         uint256 remainder = mulmod(target, numerator, denominator);
-        isError = remainder * 1000 >= numerator * target;
+        isError = remainder.safeMul(1000) >= numerator.safeMul(target);
         return isError;
     }
 
@@ -175,14 +148,14 @@ library LibMathV08 {
     /// @param numerator Numerator.
     /// @param denominator Denominator.
     /// @param target Value to multiply with numerator/denominator.
-    /// @return isError Rounding error is present.
+    /// @return Rounding error is present.
     function isRoundingErrorCeil(
         uint256 numerator,
         uint256 denominator,
         uint256 target
     ) internal pure returns (bool isError) {
         if (denominator == 0) {
-            LibRichErrorsV08.rrevert(LibMathRichErrorsV08.DivisionByZeroError());
+            LibRichErrors.rrevert(LibMathRichErrors.DivisionByZeroError());
         }
 
         // See the comments in `isRoundingError`.
@@ -194,8 +167,8 @@ library LibMathV08 {
         }
         // Compute remainder as before
         uint256 remainder = mulmod(target, numerator, denominator);
-        remainder = denominator - (remainder % denominator);
-        isError = remainder * 1000 >= numerator * target;
+        remainder = denominator.safeSub(remainder) % denominator;
+        isError = remainder.safeMul(1000) >= numerator.safeMul(target);
         return isError;
     }
 }

contracts/utils/contracts/src/LibMathRichErrors.sol

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

contracts/utils/contracts/src/Refundable.sol

@@ -0,0 +1,74 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+import "./ReentrancyGuard.sol";
+
+contract Refundable is ReentrancyGuard {
+    // This bool is used by the refund modifier to allow for lazily evaluated refunds.
+    bool internal _shouldNotRefund;
+
+    modifier refundFinalBalance() {
+        _;
+        _refundNonZeroBalanceIfEnabled();
+    }
+
+    modifier refundFinalBalanceNoReentry() {
+        _lockMutexOrThrowIfAlreadyLocked();
+        _;
+        _refundNonZeroBalanceIfEnabled();
+        _unlockMutex();
+    }
+
+    modifier disableRefundUntilEnd() {
+        if (_areRefundsDisabled()) {
+            _;
+        } else {
+            _disableRefund();
+            _;
+            _enableAndRefundNonZeroBalance();
+        }
+    }
+
+    function _refundNonZeroBalanceIfEnabled() internal {
+        if (!_areRefundsDisabled()) {
+            _refundNonZeroBalance();
+        }
+    }
+
+    function _refundNonZeroBalance() internal {
+        uint256 balance = address(this).balance;
+        if (balance > 0) {
+            msg.sender.transfer(balance);
+        }
+    }
+
+    function _disableRefund() internal {
+        _shouldNotRefund = true;
+    }
+
+    function _enableAndRefundNonZeroBalance() internal {
+        _shouldNotRefund = false;
+        _refundNonZeroBalance();
+    }
+
+    function _areRefundsDisabled() internal view returns (bool) {
+        return _shouldNotRefund;
+    }
+}

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

@@ -1,7 +1,6 @@
-// SPDX-License-Identifier: Apache-2.0
 /*
 
-  Copyright 2020 ZeroEx Intl.
+  Copyright 2019 ZeroEx Intl.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -17,11 +16,11 @@
 
 */
 
-pragma solidity ^0.8;
+pragma solidity ^0.5.9;
 
-import "./IOwnableV08.sol";
+import "./IOwnable.sol";
 
-interface IAuthorizableV08 is IOwnableV08 {
+contract IAuthorizable is IOwnable {
     // Event logged when a new address is authorized.
     event AuthorizedAddressAdded(address indexed target, address indexed caller);
 
@@ -42,16 +41,6 @@ interface IAuthorizableV08 is IOwnableV08 {
     function removeAuthorizedAddressAtIndex(address target, uint256 index) external;
 
     /// @dev Gets all authorized addresses.
-    /// @return authorizedAddresses Array of authorized addresses.
-    function getAuthorizedAddresses() external view returns (address[] memory authorizedAddresses);
-
-    /// @dev Whether an adderss is authorized to call privileged functions.
-    /// @param addr Address to query.
-    /// @return isAuthorized Whether the address is authorized.
-    function authorized(address addr) external view returns (bool isAuthorized);
-
-    /// @dev All addresseses authorized to call privileged functions.
-    /// @param idx Index of authorized address.
-    /// @return addr Authorized address.
-    function authorities(uint256 idx) external view returns (address addr);
+    /// @return Array of authorized addresses.
+    function getAuthorizedAddresses() external view returns (address[] memory);
 }

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

@@ -17,12 +17,12 @@
 
 */
 
-pragma solidity ^0.8;
+pragma solidity ^0.6.5;
 
-import "./errors/LibReentrancyGuardRichErrorsV08.sol";
-import "./errors/LibRichErrorsV08.sol";
+import "./errors/LibReentrancyGuardRichErrorsV06.sol";
+import "./errors/LibRichErrorsV06.sol";
 
-contract ReentrancyGuardV08 {
+contract ReentrancyGuardV06 {
     // Locked state of mutex.
     bool private _locked = false;
 
@@ -37,7 +37,7 @@ contract ReentrancyGuardV08 {
     function _lockMutexOrThrowIfAlreadyLocked() internal {
         // Ensure mutex is unlocked.
         if (_locked) {
-            LibRichErrorsV08.rrevert(LibReentrancyGuardRichErrorsV08.IllegalReentrancyError());
+            LibRichErrorsV06.rrevert(LibReentrancyGuardRichErrorsV06.IllegalReentrancyError());
         }
         // Lock mutex.
         _locked = true;

contracts/utils/contracts/src/v08/LibBytesV08.sol

@@ -1,434 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
-
-  Copyright 2020 ZeroEx Intl.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-*/
-
-pragma solidity ^0.8;
-
-import "./errors/LibBytesRichErrorsV08.sol";
-import "./errors/LibRichErrorsV08.sol";
-
-library LibBytesV08 {
-    using LibBytesV08 for bytes;
-
-    /// @dev Gets the memory address for a byte array.
-    /// @param input Byte array to lookup.
-    /// @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) internal pure returns (uint256 memoryAddress) {
-        assembly ("memory-safe") {
-            memoryAddress := input
-        }
-        return memoryAddress;
-    }
-
-    /// @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) internal pure returns (uint256 memoryAddress) {
-        assembly ("memory-safe") {
-            memoryAddress := add(input, 32)
-        }
-        return memoryAddress;
-    }
-
-    /// @dev Copies `length` bytes from memory location `source` to `dest`.
-    /// @param dest memory address to copy bytes to.
-    /// @param source memory address to copy bytes from.
-    /// @param length number of bytes to copy.
-    function memCopy(uint256 dest, uint256 source, uint256 length) internal pure {
-        if (length < 32) {
-            // Handle a partial word by reading destination and masking
-            // off the bits we are interested in.
-            // This correctly handles overlap, zero lengths and source == dest
-            assembly {
-                let mask := sub(exp(256, sub(32, length)), 1)
-                let s := and(mload(source), not(mask))
-                let d := and(mload(dest), mask)
-                mstore(dest, or(s, d))
-            }
-        } else {
-            // Skip the O(length) loop when source == dest.
-            if (source == dest) {
-                return;
-            }
-
-            // For large copies we copy whole words at a time. The final
-            // word is aligned to the end of the range (instead of after the
-            // previous) to handle partial words. So a copy will look like this:
-            //
-            //  ####
-            //      ####
-            //          ####
-            //            ####
-            //
-            // We handle overlap in the source and destination range by
-            // changing the copying direction. This prevents us from
-            // overwriting parts of source that we still need to copy.
-            //
-            // This correctly handles source == dest
-            //
-            if (source > dest) {
-                assembly {
-                    // We subtract 32 from `sEnd` and `dEnd` because it
-                    // is easier to compare with in the loop, and these
-                    // are also the addresses we need for copying the
-                    // last bytes.
-                    length := sub(length, 32)
-                    let sEnd := add(source, length)
-                    let dEnd := add(dest, length)
-
-                    // Remember the last 32 bytes of source
-                    // This needs to be done here and not after the loop
-                    // because we may have overwritten the last bytes in
-                    // source already due to overlap.
-                    let last := mload(sEnd)
-
-                    // Copy whole words front to back
-                    // Note: the first check is always true,
-                    // this could have been a do-while loop.
-                    for {
-
-                    } lt(source, sEnd) {
-
-                    } {
-                        mstore(dest, mload(source))
-                        source := add(source, 32)
-                        dest := add(dest, 32)
-                    }
-
-                    // Write the last 32 bytes
-                    mstore(dEnd, last)
-                }
-            } else {
-                assembly {
-                    // We subtract 32 from `sEnd` and `dEnd` because those
-                    // are the starting points when copying a word at the end.
-                    length := sub(length, 32)
-                    let sEnd := add(source, length)
-                    let dEnd := add(dest, length)
-
-                    // Remember the first 32 bytes of source
-                    // This needs to be done here and not after the loop
-                    // because we may have overwritten the first bytes in
-                    // source already due to overlap.
-                    let first := mload(source)
-
-                    // Copy whole words back to front
-                    // We use a signed comparisson here to allow dEnd to become
-                    // negative (happens when source and dest < 32). Valid
-                    // addresses in local memory will never be larger than
-                    // 2**255, so they can be safely re-interpreted as signed.
-                    // Note: the first check is always true,
-                    // this could have been a do-while loop.
-                    for {
-
-                    } slt(dest, dEnd) {
-
-                    } {
-                        mstore(dEnd, mload(sEnd))
-                        sEnd := sub(sEnd, 32)
-                        dEnd := sub(dEnd, 32)
-                    }
-
-                    // Write the first 32 bytes
-                    mstore(dest, first)
-                }
-            }
-        }
-    }
-
-    /// @dev Returns a slices from a byte array.
-    /// @param b The byte array to take a slice from.
-    /// @param from The starting index for the slice (inclusive).
-    /// @param to The final index for the slice (exclusive).
-    /// @return result The slice containing bytes at indices [from, to)
-    function slice(bytes memory b, uint256 from, uint256 to) 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) {
-            LibRichErrorsV08.rrevert(
-                LibBytesRichErrorsV08.InvalidByteOperationError(
-                    LibBytesRichErrorsV08.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
-                    from,
-                    to
-                )
-            );
-        }
-        if (to > b.length) {
-            LibRichErrorsV08.rrevert(
-                LibBytesRichErrorsV08.InvalidByteOperationError(
-                    LibBytesRichErrorsV08.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
-                    to,
-                    b.length
-                )
-            );
-        }
-
-        // Create a new bytes structure and copy contents
-        result = new bytes(to - from);
-        memCopy(result.contentAddress(), b.contentAddress() + from, result.length);
-        return result;
-    }
-
-    /// @dev Returns a slice from a byte array without preserving the input.
-    ///      When `from == 0`, the original array will match the slice.
-    ///      In other cases its state will be corrupted.
-    /// @param b The byte array to take a slice from. Will be destroyed in the process.
-    /// @param from The starting index for the slice (inclusive).
-    /// @param to The final index for the slice (exclusive).
-    /// @return result The slice containing bytes at indices [from, to)
-    function sliceDestructive(bytes memory b, uint256 from, uint256 to) 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) {
-            LibRichErrorsV08.rrevert(
-                LibBytesRichErrorsV08.InvalidByteOperationError(
-                    LibBytesRichErrorsV08.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
-                    from,
-                    to
-                )
-            );
-        }
-        if (to > b.length) {
-            LibRichErrorsV08.rrevert(
-                LibBytesRichErrorsV08.InvalidByteOperationError(
-                    LibBytesRichErrorsV08.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
-                    to,
-                    b.length
-                )
-            );
-        }
-
-        // Create a new bytes structure around [from, to) in-place.
-        assembly {
-            result := add(b, from)
-            mstore(result, sub(to, from))
-        }
-        return result;
-    }
-
-    /// @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) internal pure returns (bytes1 result) {
-        if (b.length == 0) {
-            LibRichErrorsV08.rrevert(
-                LibBytesRichErrorsV08.InvalidByteOperationError(
-                    LibBytesRichErrorsV08.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,
-                    b.length,
-                    0
-                )
-            );
-        }
-
-        // Store last byte.
-        result = b[b.length - 1];
-
-        assembly ("memory-safe") {
-            // Decrement length of byte array.
-            let newLen := sub(mload(b), 1)
-            mstore(b, newLen)
-        }
-        return result;
-    }
-
-    /// @dev Tests equality of two byte arrays.
-    /// @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(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.
-        return keccak256(lhs) == keccak256(rhs);
-    }
-
-    /// @dev Reads an address from a position in a byte array.
-    /// @param b Byte array containing an address.
-    /// @param index Index in byte array of address.
-    /// @return result address from byte array.
-    function readAddress(bytes memory b, uint256 index) internal pure returns (address result) {
-        if (b.length < index + 20) {
-            LibRichErrorsV08.rrevert(
-                LibBytesRichErrorsV08.InvalidByteOperationError(
-                    LibBytesRichErrorsV08.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
-                    b.length,
-                    index + 20 // 20 is length of address
-                )
-            );
-        }
-
-        // Add offset to index:
-        // 1. Arrays are prefixed by 32-byte length parameter (add 32 to index)
-        // 2. Account for size difference between address length and 32-byte storage word (subtract 12 from index)
-        index += 20;
-
-        // Read address from array memory
-        assembly ("memory-safe") {
-            // 1. Add index to address of bytes array
-            // 2. Load 32-byte word from memory
-            result := mload(add(b, index))
-        }
-        return result;
-    }
-
-    /// @dev Writes an address into a specific position in a byte array.
-    /// @param b Byte array to insert address into.
-    /// @param index Index in byte array of address.
-    /// @param input Address to put into byte array.
-    function writeAddress(bytes memory b, uint256 index, address input) internal pure {
-        if (b.length < index + 20) {
-            LibRichErrorsV08.rrevert(
-                LibBytesRichErrorsV08.InvalidByteOperationError(
-                    LibBytesRichErrorsV08.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
-                    b.length,
-                    index + 20 // 20 is length of address
-                )
-            );
-        }
-
-        // Add offset to index:
-        // 1. Arrays are prefixed by 32-byte length parameter (add 32 to index)
-        // 2. Account for size difference between address length and 32-byte storage word (subtract 12 from index)
-        index += 20;
-
-        // Store address into array memory
-        assembly ("memory-safe") {
-            // The address occupies 20 bytes and mstore stores 32 bytes.
-            // First fetch the 32-byte word where we'll be storing the address, then
-            // apply a mask so we have only the bytes in the word that the address will not occupy.
-            // Then combine these bytes with the address and store the 32 bytes back to memory with mstore.
-
-            // 1. Add index to address of bytes array
-            // 2. Load 32-byte word from memory
-            // 3. Apply 12-byte mask to obtain extra bytes occupying word of memory where we'll store the address
-            let neighbors := and(
-                mload(add(b, index)),
-                0xffffffffffffffffffffffff0000000000000000000000000000000000000000
-            )
-
-            // Make sure input address is clean.
-            // (Solidity does not guarantee this)
-            input := and(input, 0xffffffffffffffffffffffffffffffffffffffff)
-
-            // Store the neighbors and address into memory
-            mstore(add(b, index), xor(input, neighbors))
-        }
-    }
-
-    /// @dev Reads a bytes32 value from a position in a byte array.
-    /// @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(bytes memory b, uint256 index) internal pure returns (bytes32 result) {
-        if (b.length < index + 32) {
-            LibRichErrorsV08.rrevert(
-                LibBytesRichErrorsV08.InvalidByteOperationError(
-                    LibBytesRichErrorsV08.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
-                    b.length,
-                    index + 32
-                )
-            );
-        }
-
-        // Arrays are prefixed by a 256 bit length parameter
-        index += 32;
-
-        // Read the bytes32 from array memory
-        assembly ("memory-safe") {
-            result := mload(add(b, index))
-        }
-        return result;
-    }
-
-    /// @dev Writes a bytes32 into a specific position in a byte array.
-    /// @param b Byte array to insert <input> into.
-    /// @param index Index in byte array of <input>.
-    /// @param input bytes32 to put into byte array.
-    function writeBytes32(bytes memory b, uint256 index, bytes32 input) internal pure {
-        if (b.length < index + 32) {
-            LibRichErrorsV08.rrevert(
-                LibBytesRichErrorsV08.InvalidByteOperationError(
-                    LibBytesRichErrorsV08.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
-                    b.length,
-                    index + 32
-                )
-            );
-        }
-
-        // Arrays are prefixed by a 256 bit length parameter
-        index += 32;
-
-        // Read the bytes32 from array memory
-        assembly ("memory-safe") {
-            mstore(add(b, index), input)
-        }
-    }
-
-    /// @dev Reads a uint256 value from a position in a byte array.
-    /// @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(bytes memory b, uint256 index) internal pure returns (uint256 result) {
-        result = uint256(readBytes32(b, index));
-        return result;
-    }
-
-    /// @dev Writes a uint256 into a specific position in a byte array.
-    /// @param b Byte array to insert <input> into.
-    /// @param index Index in byte array of <input>.
-    /// @param input uint256 to put into byte array.
-    function writeUint256(bytes memory b, uint256 index, uint256 input) internal pure {
-        writeBytes32(b, index, bytes32(input));
-    }
-
-    /// @dev Reads an unpadded bytes4 value from a position in a byte array.
-    /// @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(bytes memory b, uint256 index) internal pure returns (bytes4 result) {
-        if (b.length < index + 4) {
-            LibRichErrorsV08.rrevert(
-                LibBytesRichErrorsV08.InvalidByteOperationError(
-                    LibBytesRichErrorsV08.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,
-                    b.length,
-                    index + 4
-                )
-            );
-        }
-
-        // Arrays are prefixed by a 32 byte length field
-        index += 32;
-
-        // Read the bytes4 from array memory
-        assembly ("memory-safe") {
-            result := mload(add(b, index))
-        }
-        return result;
-    }
-
-    /// @dev Writes a new length to a byte array.
-    ///      Decreasing length will lead to removing the corresponding lower order bytes from the byte array.
-    ///      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) internal pure {
-        assembly {
-            mstore(b, length)
-        }
-    }
-}

contracts/utils/contracts/src/v08/OwnableV08.sol

@@ -1,56 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
-
-  Copyright 2019 ZeroEx Intl.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-*/
-
-pragma solidity ^0.8;
-
-import "./interfaces/IOwnableV08.sol";
-import "./errors/LibRichErrorsV08.sol";
-import "./errors/LibOwnableRichErrorsV08.sol";
-
-contract OwnableV08 is IOwnableV08 {
-    /// @dev The owner of this contract.
-    /// @return 0 The owner address.
-    address public override owner;
-
-    constructor() {
-        owner = msg.sender;
-    }
-
-    modifier onlyOwner() {
-        _assertSenderIsOwner();
-        _;
-    }
-
-    /// @dev Change the owner of this contract.
-    /// @param newOwner New owner address.
-    function transferOwnership(address newOwner) public override onlyOwner {
-        if (newOwner == address(0)) {
-            LibRichErrorsV08.rrevert(LibOwnableRichErrorsV08.TransferOwnerToZeroError());
-        } else {
-            owner = newOwner;
-            emit OwnershipTransferred(msg.sender, newOwner);
-        }
-    }
-
-    function _assertSenderIsOwner() internal view {
-        if (msg.sender != owner) {
-            LibRichErrorsV08.rrevert(LibOwnableRichErrorsV08.OnlyOwnerError(msg.sender, owner));
-        }
-    }
-}

contracts/utils/contracts/src/v08/errors/LibBytesRichErrorsV08.sol

@@ -1,44 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
-
-  Copyright 2020 ZeroEx Intl.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-*/
-
-pragma solidity ^0.8;
-
-library LibBytesRichErrorsV08 {
-    enum InvalidByteOperationErrorCodes {
-        FromLessThanOrEqualsToRequired,
-        ToLessThanOrEqualsLengthRequired,
-        LengthGreaterThanZeroRequired,
-        LengthGreaterThanOrEqualsFourRequired,
-        LengthGreaterThanOrEqualsTwentyRequired,
-        LengthGreaterThanOrEqualsThirtyTwoRequired,
-        LengthGreaterThanOrEqualsNestedBytesLengthRequired,
-        DestinationLengthGreaterThanOrEqualSourceLengthRequired
-    }
-
-    // bytes4(keccak256("InvalidByteOperationError(uint8,uint256,uint256)"))
-    bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR = 0x28006595;
-
-    function InvalidByteOperationError(
-        InvalidByteOperationErrorCodes errorCode,
-        uint256 offset,
-        uint256 required
-    ) internal pure returns (bytes memory) {
-        return abi.encodeWithSelector(INVALID_BYTE_OPERATION_ERROR_SELECTOR, errorCode, offset, required);
-    }
-}

contracts/utils/contracts/src/v08/errors/LibMathRichErrorsV08.sol

@@ -1,40 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
-
-  Copyright 2020 ZeroEx Intl.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-*/
-
-pragma solidity ^0.8;
-
-library LibMathRichErrorsV08 {
-    // bytes4(keccak256("DivisionByZeroError()"))
-    bytes internal constant DIVISION_BY_ZERO_ERROR = hex"a791837c";
-
-    // bytes4(keccak256("RoundingError(uint256,uint256,uint256)"))
-    bytes4 internal constant ROUNDING_ERROR_SELECTOR = 0x339f3de2;
-
-    function DivisionByZeroError() internal pure returns (bytes memory) {
-        return DIVISION_BY_ZERO_ERROR;
-    }
-
-    function RoundingError(
-        uint256 numerator,
-        uint256 denominator,
-        uint256 target
-    ) internal pure returns (bytes memory) {
-        return abi.encodeWithSelector(ROUNDING_ERROR_SELECTOR, numerator, denominator, target);
-    }
-}

contracts/utils/contracts/src/v08/errors/LibOwnableRichErrorsV08.sol

@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
-
-  Copyright 2020 ZeroEx Intl.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-*/
-pragma solidity ^0.8;
-
-library LibOwnableRichErrorsV08 {
-    // bytes4(keccak256("OnlyOwnerError(address,address)"))
-    bytes4 internal constant ONLY_OWNER_ERROR_SELECTOR = 0x1de45ad1;
-
-    // bytes4(keccak256("TransferOwnerToZeroError()"))
-    bytes internal constant TRANSFER_OWNER_TO_ZERO_ERROR_BYTES = hex"e69edc3e";
-
-    function OnlyOwnerError(address sender, address owner) internal pure returns (bytes memory) {
-        return abi.encodeWithSelector(ONLY_OWNER_ERROR_SELECTOR, sender, owner);
-    }
-
-    function TransferOwnerToZeroError() internal pure returns (bytes memory) {
-        return TRANSFER_OWNER_TO_ZERO_ERROR_BYTES;
-    }
-}

contracts/utils/contracts/src/v08/errors/LibRichErrorsV08.sol

@@ -1,42 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
-
-  Copyright 2020 ZeroEx Intl.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-*/
-
-pragma solidity ^0.8;
-
-library LibRichErrorsV08 {
-    // bytes4(keccak256("Error(string)"))
-    bytes4 internal constant STANDARD_ERROR_SELECTOR = 0x08c379a0;
-
-    /// @dev ABI encode a standard, string revert error payload.
-    ///      This is the same payload that would be included by a `revert(string)`
-    ///      solidity statement. It has the function signature `Error(string)`.
-    /// @param message The error string.
-    /// @return The ABI encoded error.
-    function StandardError(string memory message) internal pure returns (bytes memory) {
-        return abi.encodeWithSelector(STANDARD_ERROR_SELECTOR, bytes(message));
-    }
-
-    /// @dev Reverts an encoded rich revert reason `errorData`.
-    /// @param errorData ABI encoded error data.
-    function rrevert(bytes memory errorData) internal pure {
-        assembly ("memory-safe") {
-            revert(add(errorData, 0x20), mload(errorData))
-        }
-    }
-}

contracts/utils/contracts/src/v08/errors/LibSafeMathRichErrorsV08.sol

@@ -1,50 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
-
-  Copyright 2020 ZeroEx Intl.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-*/
-
-pragma solidity ^0.8;
-
-library LibSafeMathRichErrorsV08 {
-    // bytes4(keccak256("Uint256BinOpError(uint8,uint256,uint256)"))
-    bytes4 internal constant UINT256_BINOP_ERROR_SELECTOR = 0xe946c1bb;
-
-    // bytes4(keccak256("Uint256DowncastError(uint8,uint256)"))
-    bytes4 internal constant UINT256_DOWNCAST_ERROR_SELECTOR = 0xc996af7b;
-
-    enum BinOpErrorCodes {
-        ADDITION_OVERFLOW,
-        MULTIPLICATION_OVERFLOW,
-        SUBTRACTION_UNDERFLOW,
-        DIVISION_BY_ZERO
-    }
-
-    enum DowncastErrorCodes {
-        VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT32,
-        VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT64,
-        VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT96,
-        VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT128
-    }
-
-    function Uint256BinOpError(BinOpErrorCodes errorCode, uint256 a, uint256 b) internal pure returns (bytes memory) {
-        return abi.encodeWithSelector(UINT256_BINOP_ERROR_SELECTOR, errorCode, a, b);
-    }
-
-    function Uint256DowncastError(DowncastErrorCodes errorCode, uint256 a) internal pure returns (bytes memory) {
-        return abi.encodeWithSelector(UINT256_DOWNCAST_ERROR_SELECTOR, errorCode, a);
-    }
-}

contracts/utils/contracts/src/v08/interfaces/IOwnableV08.sol

@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
-
-  Copyright 2020 ZeroEx Intl.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-*/
-
-pragma solidity ^0.8;
-
-interface IOwnableV08 {
-    /// @dev Emitted by Ownable when ownership is transferred.
-    /// @param previousOwner The previous owner of the contract.
-    /// @param newOwner The new owner of the contract.
-    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
-
-    /// @dev Transfers ownership of the contract to a new address.
-    /// @param newOwner The address that will become the owner.
-    function transferOwnership(address newOwner) external;
-
-    /// @dev The owner of this contract.
-    /// @return ownerAddress The owner address.
-    function owner() external view returns (address ownerAddress);
-}