Publish

- @0x/contracts-asset-proxy@2.2.4
 - @0x/contracts-coordinator@2.0.9
 - @0x/contracts-dev-utils@0.0.6
 - @0x/contracts-erc1155@1.1.11
 - @0x/contracts-erc20@2.2.10
 - @0x/contracts-erc721@2.1.11
 - @0x/contracts-exchange-forwarder@3.0.8
 - @0x/contracts-exchange-libs@3.0.4
 - @0x/contracts-exchange@2.1.10
 - @0x/contracts-extensions@4.0.4
 - @0x/contracts-multisig@3.1.10
 - @0x/contracts-test-utils@3.1.12
 - @0x/contracts-utils@3.2.0
 - 0x.js@6.0.14
 - @0x/abi-gen-templates@2.4.0
 - @0x/abi-gen-wrappers@5.1.0
 - @0x/abi-gen@3.1.2
 - @0x/assert@2.1.2
 - @0x/asset-buyer@6.1.10
 - @0x/asset-swapper@1.0.0
 - @0x/base-contract@5.3.0
 - @0x/connect@5.0.15
 - @0x/contract-artifacts@2.0.3
 - @0x/contract-wrappers@10.1.0
 - @0x/contracts-gen@1.0.12
 - @0x/dev-utils@2.2.6
 - @0x/fill-scenarios@3.0.15
 - @0x/json-schemas@3.1.12
 - @0x/migrations@4.1.11
 - @0x/order-utils@8.2.4
 - @0x/order-watcher@4.0.16
 - @0x/sol-compiler@3.1.11
 - @0x/sol-coverage@3.0.8
 - @0x/sol-doc@2.0.15
 - @0x/sol-profiler@3.1.10
 - @0x/sol-trace@2.0.16
 - @0x/sol-tracing-utils@6.0.15
 - @0x/sra-spec@2.0.13
 - @0x/subproviders@5.0.0
 - @0x/utils@4.4.2
 - @0x/web3-wrapper@6.0.9

.circleci/config.yml

@@ -11,9 +11,14 @@ jobs:
         steps:
             - checkout
             - run: echo 'export PATH=$HOME/CIRCLE_PROJECT_REPONAME/node_modules/.bin:$PATH' >> $BASH_ENV
+            - run:
+                  # HACK(albrow): Without this, yarn commands will sometimes
+                  # fail with a "permission denied" error.
+                  name: Set npm path
+                  command: npm set prefix=/home/circleci/npm && echo 'export PATH=$HOME/circleci/npm/bin:$PATH' >> /home/circleci/.bashrc
             - run:
                   name: install-yarn
-                  command: sudo npm install --global yarn@1.9.4
+                  command: npm install --global yarn@1.9.4
             - run:
                   name: yarn
                   command: yarn --frozen-lockfile --ignore-engines install || yarn --frozen-lockfile --ignore-engines install
@@ -24,6 +29,14 @@ jobs:
                   key: repo-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
                       - ~/repo
+            - save_cache:
+                  key: python-contract-wrappers-{{ .Environment.CIRCLE_SHA1 }}
+                  paths:
+                      - ~/repo/packages/python-contract-wrappers/generated
+            - store_artifacts:
+                  path: ~/repo/packages/python-contract-wrappers/generated
+            - store_artifacts:
+                  path: ~/repo/packages/abi-gen/test-cli/output
     build-website:
         resource_class: medium+
         docker:
@@ -42,15 +55,7 @@ jobs:
             - restore_cache:
                   keys:
                       - repo-{{ .Environment.CIRCLE_SHA1 }}
-            - run: yarn wsrun test:circleci @0x/contracts-multisig
-            - run: yarn wsrun test:circleci @0x/contracts-utils
-            - run: yarn wsrun test:circleci @0x/contracts-exchange-libs
-            - run: yarn wsrun test:circleci @0x/contracts-erc20
-            - run: yarn wsrun test:circleci @0x/contracts-erc721
-            - run: yarn wsrun test:circleci @0x/contracts-extensions
-            - run: yarn wsrun test:circleci @0x/contracts-asset-proxy
-            - run: yarn wsrun test:circleci @0x/contracts-exchange
-            - run: yarn wsrun test:circleci @0x/contracts-exchange-forwarder
+            - run: yarn wsrun test:circleci @0x/contracts-multisig @0x/contracts-utils @0x/contracts-exchange-libs @0x/contracts-erc20 @0x/contracts-erc721 @0x/contracts-erc1155 @0x/contracts-extensions @0x/contracts-asset-proxy @0x/contracts-exchange @0x/contracts-exchange-forwarder @0x/contracts-coordinator @0x/contracts-dev-utils
     test-contracts-geth:
         docker:
             - image: circleci/node:9-browsers
@@ -62,15 +67,7 @@ jobs:
                       - repo-{{ .Environment.CIRCLE_SHA1 }}
             # HACK(albrow): we need to sleep 10 seconds to ensure the devnet is
             # initialized
-            - run: sleep 10 && TEST_PROVIDER=geth yarn wsrun test @0x/contracts-multisig
-            - run: TEST_PROVIDER=geth yarn wsrun test:circleci @0x/contracts-utils
-            - run: TEST_PROVIDER=geth yarn wsrun test:circleci @0x/contracts-exchange-libs
-            - run: TEST_PROVIDER=geth yarn wsrun test:circleci @0x/contracts-erc20
-            - run: TEST_PROVIDER=geth yarn wsrun test:circleci @0x/contracts-erc721
-            - run: TEST_PROVIDER=geth yarn wsrun test:circleci @0x/contracts-extensions
-            - run: TEST_PROVIDER=geth yarn wsrun test:circleci @0x/contracts-asset-proxy
-            - run: TEST_PROVIDER=geth yarn wsrun test:circleci @0x/contracts-exchange
-            - run: TEST_PROVIDER=geth yarn wsrun test:circleci @0x/contracts-exchange-forwarder
+            - run: sleep 10 && TEST_PROVIDER=geth yarn wsrun test:circleci @0x/contracts-multisig @0x/contracts-utils @0x/contracts-exchange-libs @0x/contracts-erc20 @0x/contracts-erc721 @0x/contracts-erc1155 @0x/contracts-extensions @0x/contracts-asset-proxy @0x/contracts-exchange @0x/contracts-exchange-forwarder @0x/contracts-coordinator @0x/contracts-dev-utils
     test-publish:
         resource_class: medium+
         docker:
@@ -91,20 +88,6 @@ jobs:
                   keys:
                       - repo-{{ .Environment.CIRCLE_SHA1 }}
             - run: yarn test:generate_docs:circleci
-    test-pipeline:
-        docker:
-            - image: circleci/node:9
-            - image: postgres:11-alpine
-        working_directory: ~/repo
-        steps:
-            - restore_cache:
-                  keys:
-                      - repo-{{ .Environment.CIRCLE_SHA1 }}
-            - run: ZEROEX_DATA_PIPELINE_TEST_DB_URL='postgresql://postgres@localhost/postgres' yarn wsrun test:circleci @0x/pipeline
-            - save_cache:
-                  key: coverage-pipeline-{{ .Environment.CIRCLE_SHA1 }}
-                  paths:
-                      - ~/repo/packages/pipeline/coverage/lcov.info
     test-rest:
         docker:
             - image: circleci/node:9-browsers
@@ -115,13 +98,14 @@ jobs:
                       - repo-{{ .Environment.CIRCLE_SHA1 }}
             - run: yarn wsrun test:circleci @0x/contracts-test-utils
             - run: yarn wsrun test:circleci @0x/abi-gen
+            - run: yarn wsrun test:circleci @0x/asset-buyer
+            - run: yarn wsrun test:circleci @0x/contract-artifacts
             - run: yarn wsrun test:circleci @0x/assert
             - run: yarn wsrun test:circleci @0x/base-contract
             - run: yarn wsrun test:circleci @0x/connect
             - run: yarn wsrun test:circleci @0x/contract-wrappers
             - run: yarn wsrun test:circleci @0x/dev-utils
             - run: yarn wsrun test:circleci @0x/json-schemas
-            - run: yarn wsrun test:circleci @0x/metacoin
             - run: yarn wsrun test:circleci @0x/order-utils
             - run: yarn wsrun test:circleci @0x/order-watcher
             - run: yarn wsrun test:circleci @0x/sol-compiler
@@ -139,6 +123,10 @@ jobs:
                   key: coverage-assert-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
                       - ~/repo/packages/assert/coverage/lcov.info
+            - save_cache:
+                  key: coverage-asset-buyer-{{ .Environment.CIRCLE_SHA1 }}
+                  paths:
+                      - ~/repo/packages/asset-buyer/coverage/lcov.info
             - save_cache:
                   key: coverage-base-contract-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
@@ -159,10 +147,6 @@ jobs:
                   key: coverage-json-schemas-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
                       - ~/repo/packages/json-schemas/coverage/lcov.info
-            - save_cache:
-                  key: coverage-metacoin-{{ .Environment.CIRCLE_SHA1 }}
-                  paths:
-                      - ~/repo/packages/metacoin/coverage/lcov.info
             - save_cache:
                   key: coverage-order-utils-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
@@ -197,28 +181,35 @@ jobs:
             - image: circleci/python
             - image: 0xorg/ganache-cli:2.2.2
             - image: 0xorg/launch-kit-ci
-              command: |
-                  yarn start:ts -p 3000:3000
+              environment:
+                  RPC_URL: http://localhost:8545
+                  NETWORK_ID: 50
+                  WHITELIST_ALL_TOKENS: True
+              command: bash -c "until curl -sfd'{\"method\":\"net_listening\"}' http://localhost:8545 | grep true; do continue; done; forever ts/lib/index.js"
         steps:
             - checkout
             - run: sudo chown -R circleci:circleci /usr/local/bin
             - run: sudo chown -R circleci:circleci /usr/local/lib/python3.7
             - restore_cache:
-                  key: deps9-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }}
+                  key: installed-py-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }}
+            - restore_cache:
+                  key: python-contract-wrappers-{{ .Environment.CIRCLE_SHA1 }}
             - run:
                   command: |
                       cd python-packages
                       python -m ensurepip
+                      ./pre_install
                       ./install
             - save_cache:
-                  key: deps9-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }}
+                  key: installed-py-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
                       - '/usr/local/bin'
                       - '/usr/local/lib/python3.7/site-packages'
             - run:
                   command: |
                       cd python-packages
-                      ./cmd_pkgs_in_dep_order.py coverage run setup.py test
+                      ./parallel coverage run setup.py test
+                      ./build_docs
             - save_cache:
                   key: coverage-python-contract-addresses-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
@@ -243,6 +234,24 @@ jobs:
                   key: coverage-python-sra-client-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
                       - ~/repo/python-packages/sra_client/.coverage
+            - store_artifacts:
+                  path: ~/repo/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc20_token/__init__.py
+            - store_artifacts:
+                  path: ~/repo/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/exchange/__init__.py
+            - store_artifacts:
+                  path: ~/repo/python-packages/contract_addresses/build
+            - store_artifacts:
+                  path: ~/repo/python-packages/contract_artifacts/build
+            - store_artifacts:
+                  path: ~/repo/python-packages/contract_wrappers/build
+            - store_artifacts:
+                  path: ~/repo/python-packages/json_schemas/build
+            - store_artifacts:
+                  path: ~/repo/python-packages/middlewares/build
+            - store_artifacts:
+                  path: ~/repo/python-packages/order_utils/build
+            - store_artifacts:
+                  path: ~/repo/python-packages/sra_client/build
     test-rest-python:
         working_directory: ~/repo
         docker:
@@ -252,14 +261,14 @@ jobs:
             - run: sudo chown -R circleci:circleci /usr/local/bin
             - run: sudo chown -R circleci:circleci /usr/local/lib/python3.7
             - restore_cache:
-                  key: deps9-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }}
+                  key: installed-py-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }}
             - run:
                   command: |
                       cd python-packages/order_utils
                       python -m ensurepip
                       python -m pip install .
             - save_cache:
-                  key: deps9-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }}
+                  key: installed-py-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
                       - '/usr/local/bin'
                       - '/usr/local/lib/python3.7/site-packages'
@@ -280,11 +289,14 @@ jobs:
             - run: sudo chown -R circleci:circleci /usr/local/bin
             - run: sudo chown -R circleci:circleci /usr/local/lib/python3.7
             - restore_cache:
-                  key: deps9-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }}
+                  key: installed-py-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }}
+            - restore_cache:
+                  key: python-contract-wrappers-{{ .Environment.CIRCLE_SHA1 }}
             - run:
                   command: |
                       python -m ensurepip
                       cd python-packages
+                      ./pre_install
                       ./install
                       ./lint
     static-tests:
@@ -314,6 +326,9 @@ jobs:
             - restore_cache:
                   keys:
                       - coverage-assert-{{ .Environment.CIRCLE_SHA1 }}
+            - restore_cache:
+                  keys:
+                      - coverage-asset-buyer-{{ .Environment.CIRCLE_SHA1 }}
             - restore_cache:
                   keys:
                       - coverage-base-contract-{{ .Environment.CIRCLE_SHA1 }}
@@ -329,9 +344,6 @@ jobs:
             - restore_cache:
                   keys:
                       - coverage-json-schemas-{{ .Environment.CIRCLE_SHA1 }}
-            - restore_cache:
-                  keys:
-                      - coverage-metacoin-{{ .Environment.CIRCLE_SHA1 }}
             - restore_cache:
                   keys:
                       - coverage-order-utils-{{ .Environment.CIRCLE_SHA1 }}
@@ -386,12 +398,11 @@ workflows:
             - test-contracts-ganache:
                   requires:
                       - build
-            - test-contracts-geth:
-                  requires:
-                      - build
-            - test-pipeline:
-                  requires:
-                      - build
+            # TODO(albrow): Tests always fail on Geth right now because our fork
+            # is outdated. Uncomment once we have updated our Geth fork.
+            # - test-contracts-geth:
+            #       requires:
+            #           - build
             - test-rest:
                   requires:
                       - build
@@ -411,6 +422,8 @@ workflows:
             - static-tests-python:
                   requires:
                       - test-python
-            - test-python
+            - test-python:
+                  requires:
+                      - build
             # skip python tox run for now, as we don't yet have multiple test environments to support.
             #- test-rest-python

.gitattributes

@@ -1,7 +1,7 @@
 *.sol linguist-language=Solidity
 
 # Automatically collapse generated files in GitHub.
-*.svg linguist-generated
-packages/contract-artifacts/artifacts/*json linguist-generated
-packages/abi-gen-wrappers/wrappers/*.ts liguist-generated
+*.svg linguist-generated=true
+packages/contract-artifacts/artifacts/*json linguist-generated=true
+packages/abi-gen-wrappers/src/generated-wrappers/*.ts linguist-generated=true
 

.github/autolabeler.yml

@@ -1,43 +1,40 @@
 python: ['python-packages']
 contracts: ['contracts']
-sol-doc: ['packages/sol-doc']
-sol-resolver: ['packages/sol-resolver']
-contracts-gen: ['packages/contracts-gen']
-sra-spec: ['packages/sra-spec']
-subproviders: ['packages/subproviders']
-contract-addresses: ['packages/contract-addresses']
-migrations: ['packages/migrations']
-web3-wrapper: ['packages/web3-wrapper']
-sol-compiler: ['packages/sol-compiler']
-types: ['packages/types']
-instant: ['packages/instant']
-abi-gen-templates: ['packages/abi-gen-templates']
-abi-gen: ['packages/abi-gen']
-website: ['packages/website']
-sol-coverage: ['packages/sol-coverage']
-sol-profiler: ['packages/sol-profiler']
-sol-trace: ['packages/sol-trace']
-sol-tracing-utils: ['packages/sol-tracing-utils']
-utils: ['packages/utils']
-tslint-config: ['packages/tslint-config']
-asset-buyer: ['packages/asset-buyer']
-order-watcher: ['packages/order-watcher']
-react-docs: ['packages/react-docs']
-order-utils: ['packages/order-utils']
-react-shared: ['packages/react-shared']
-assert: ['packages/assert']
-base-contract: ['packages/base-contract']
-typescript-typings: ['packages/typescript-typings']
+@0x/sol-doc: ['packages/sol-doc']
+@0x/sol-resolver: ['packages/sol-resolver']
+@0x/contracts-gen: ['packages/contracts-gen']
+@0x/sra-spec: ['packages/sra-spec']
+@0x/subproviders: ['packages/subproviders']
+@0x/contract-addresses: ['packages/contract-addresses']
+@0x/migrations: ['packages/migrations']
+@0x/web3-wrapper: ['packages/web3-wrapper']
+@0x/sol-compiler: ['packages/sol-compiler']
+@0x/types: ['packages/types']
+@0x/instant: ['packages/instant']
+@0x/abi-gen-templates: ['packages/abi-gen-templates']
+@0x/abi-gen: ['packages/abi-gen']
+@0x/website: ['packages/website']
+@0x/sol-coverage: ['packages/sol-coverage']
+@0x/sol-profiler: ['packages/sol-profiler']
+@0x/sol-trace: ['packages/sol-trace']
+@0x/sol-tracing-utils: ['packages/sol-tracing-utils']
+@0x/utils: ['packages/utils']
+@0x/tslint-config: ['packages/tslint-config']
+@0x/asset-buyer: ['packages/asset-buyer']
+@0x/order-watcher: ['packages/order-watcher']
+@0x/order-utils: ['packages/order-utils']
+@0x/assert: ['packages/assert']
+@0x/base-contract: ['packages/base-contract']
+@0x/typescript-typings: ['packages/typescript-typings']
 0x.js: ['packages/0x.js']
-abi-gen-wrappers: ['packages/abi-gen-wrappers']
-metacoin: ['packages/metacoin']
-contract-artifacts: ['packages/contract-artifacts']
-dev-utils: ['packages/dev-utils']
-contract-wrappers: ['packages/contract-wrappers']
-json-schemas: ['packages/json-schemas']
-ethereum-types: ['ethereum-types']
-connect: ['packages/connect']
-fill-scenarios: ['packages/fill-scenarios']
-dev-tools-pages: ['packages/dev-tools-pages']
-testnet-faucets: ['packages/testnet-faucets']
-monorepo-scripts: ['packages/monorepo-scripts']
+@0x/abi-gen-wrappers: ['packages/abi-gen-wrappers']
+@0x/contract-artifacts: ['packages/contract-artifacts']
+@0x/dev-utils: ['packages/dev-utils']
+@0x/contract-wrappers: ['packages/contract-wrappers']
+@0x/json-schemas: ['packages/json-schemas']
+@0x/ethereum-types: ['ethereum-types']
+@0x/connect: ['packages/connect']
+@0x/fill-scenarios: ['packages/fill-scenarios']
+@0x/dev-tools-pages: ['packages/dev-tools-pages']
+@0x/testnet-faucets: ['packages/testnet-faucets']
+@0x/monorepo-scripts: ['packages/monorepo-scripts']

.gitignore

@@ -77,12 +77,12 @@ TODO.md
 
 packages/website/public/bundle*
 packages/dev-tools-pages/public/bundle*
-packages/react-docs/example/public/bundle*
 
 # server cli
 packages/testnet-faucets/server/
 
 # generated contract artifacts/
+contracts/coordinator/generated-artifacts/
 contracts/exchange/generated-artifacts/
 contracts/asset-proxy/generated-artifacts/
 contracts/multisig/generated-artifacts/
@@ -90,13 +90,17 @@ contracts/utils/generated-artifacts/
 contracts/exchange-libs/generated-artifacts/
 contracts/erc20/generated-artifacts/
 contracts/erc721/generated-artifacts/
+contracts/erc1155/generated-artifacts/
 contracts/extensions/generated-artifacts/
 contracts/exchange-forwarder/generated-artifacts/
+contracts/dev-utils/generated-artifacts/
 packages/sol-tracing-utils/test/fixtures/artifacts/
-packages/metacoin/artifacts/
+python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/
 
 # generated contract wrappers
-packages/abi-gen-wrappers/wrappers
+packages/abi-gen-wrappers/src/generated-wrappers/
+packages/python-contract-wrappers/generated/
+contracts/coordinator/generated-wrappers/
 contracts/exchange/generated-wrappers/
 contracts/asset-proxy/generated-wrappers/
 contracts/multisig/generated-wrappers/
@@ -104,9 +108,15 @@ contracts/utils/generated-wrappers/
 contracts/exchange-libs/generated-wrappers/
 contracts/erc20/generated-wrappers/
 contracts/erc721/generated-wrappers/
+contracts/erc1155/generated-wrappers/
 contracts/extensions/generated-wrappers/
 contracts/exchange-forwarder/generated-wrappers/
-packages/metacoin/src/contract_wrappers
+contracts/dev-utils/generated-wrappers/
+python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc20_token/__init__.py
+python-packages/contract_wrappers/src/zero_ex/contract_wrappers/exchange/__init__.py
+
+# cli test output
+packages/abi-gen/test-cli/output
 
 # solc-bin in sol-compiler
 packages/sol-compiler/solc_bin/
@@ -123,3 +133,6 @@ python-packages/*/dist
 __pycache__
 python-packages/*/src/*.egg-info
 python-packages/*/.coverage
+
+# python keeps package-local copies of json schemas
+python-packages/json_schemas/src/zero_ex/json_schemas/schemas

.prettierignore

@@ -1,5 +1,7 @@
 lib
 .nyc_output
+/contracts/coordinator/generated-wrappers
+/contracts/coordinator/generated-artifacts
 /contracts/exchange/generated-wrappers
 /contracts/exchange/generated-artifacts
 /contracts/asset-proxy/generated-wrappers
@@ -14,17 +16,17 @@ lib
 /contracts/erc20/generated-artifacts
 /contracts/erc721/generated-wrappers
 /contracts/erc721/generated-artifacts
+/contracts/erc1155/generated-wrappers
+/contracts/erc1155/generated-artifacts
 /contracts/extensions/generated-wrappers
 /contracts/extensions/generated-artifacts
 /contracts/exchange-forwarder/generated-wrappers
 /contracts/exchange-forwarder/generated-artifacts
-/packages/abi-gen-wrappers/src/generated-wrappers
-/packages/contract-artifacts/artifacts
-/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts
+/contracts/dev-utils/generated-wrappers
+/contracts/dev-utils/generated-artifacts
+/packages/abi-gen/test-cli/output
 /packages/json-schemas/schemas
 /python-packages/json_schemas/src/zero_ex/json_schemas/schemas
-/packages/metacoin/src/contract_wrappers
-/packages/metacoin/artifacts
 /packages/sra-spec/public/
 /packages/dev-tools-pages/ts/**/data.json
 package.json
@@ -33,3 +35,6 @@ packages/sol-coverage/test/fixtures/artifacts
 .pytest_cache
 .mypy_cache
 .tox
+packages/abi-gen/test-cli/fixtures/artifacts/AbiGenDummy.json
+packages/abi-gen/test-cli/fixtures/artifacts/LibDummy.json
+packages/abi-gen/test-cli/fixtures/artifacts/TestLibDummy.json

CODEOWNERS

@@ -11,18 +11,18 @@ packages/website/  @BMillman19 @fragosti @fabioberger @steveklebanoff
 
 # Dev tools & setup
 .circleci/ @LogvinovLeon
-packages/abi-gen/ @LogvinovLeon
-packages/base-contract/ @LogvinovLeon
+packages/abi-gen/ @feuGeneA
+packages/base-contract/ @xianny
 packages/connect/ @fragosti 
-packages/abi-gen-templates/ @LogvinovLeon
+packages/abi-gen-templates/ @feuGeneA @xianny
 packages/contract-addresses/ @albrow
 packages/contract-artifacts/ @albrow
 packages/dev-utils/ @LogvinovLeon @fabioberger
 packages/devnet/ @albrow
 packages/ethereum-types/ @LogvinovLeon
-packages/metacoin/ @LogvinovLeon
 packages/monorepo-scripts/ @fabioberger
 packages/order-utils/ @fabioberger @LogvinovLeon 
+packages/python-contract-wrappers/ @feuGeneA
 packages/sol-compiler/ @LogvinovLeon
 packages/sol-coverage/ @LogvinovLeon
 packages/sol-profiler/ @LogvinovLeon
@@ -33,6 +33,7 @@ packages/subproviders/ @fabioberger @dekz
 packages/verdaccio/ @albrow
 packages/web3-wrapper/ @LogvinovLeon @fabioberger
 python-packages/ @feuGeneA
+packages/utils/ @hysz
 
 # Protocol/smart contracts
-contracts/core/test/ @albrow
+contracts/ @abandeali1 @hysz

ISSUE_TEMPLATE.md

@@ -2,7 +2,7 @@
 
 <!--- Before submitting please check to see if this issue was already reported -->
 
-<!--- Provide a general summary of the issue in the Title above -->
+<!--- Prefix your issue title with the package name it relates to (e.g., `0x.js: ` or `general:`) -->
 
 ## Expected Behavior
 

README.md

@@ -34,18 +34,23 @@ Visit our [developer portal](https://0xproject.com/docs/order-utils) for a compr
 
 ### Solidity Packages
 
+These packages are all under development. See [/contracts/README.md](/contracts/README.md) for a list of deployed packages.
+
 | Package                                                             | Version                                                                                                                                     | Description                                                                                                                                                                                                                                           |
 | ------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | [`@0x/contracts-asset-proxy`](/contracts/asset-proxy)               | [![npm](https://img.shields.io/npm/v/@0x/contracts-asset-proxy.svg)](https://www.npmjs.com/package/@0x/contracts-asset-proxy)               | [`AssetProxy`](https://github.com/0xProject/0x-protocol-specification/blob/master/v2/v2-specification.md#assetproxy) contracts used within the protocol                                                                                               |
 | [`@0x/contracts-erc20`](/contracts/erc20)                           | [![npm](https://img.shields.io/npm/v/@0x/contracts-erc20.svg)](https://www.npmjs.com/package/@0x/contracts-erc20)                           | Implementations of various ERC20 tokens                                                                                                                                                                                                               |
 | [`@0x/contracts-erc721`](/contracts/erc721)                         | [![npm](https://img.shields.io/npm/v/@0x/contracts-erc721.svg)](https://www.npmjs.com/package/@0x/contracts-erc721)                         | Implementations of various ERC721 tokens                                                                                                                                                                                                              |
+| [`@0x/contracts-erc1155`](/contracts/erc1155)                       | [![npm](https://img.shields.io/npm/v/@0x/contracts-erc1155.svg)](https://www.npmjs.com/package/@0x/contracts-erc1155)                       | Implementations of various ERC1155 tokens                                                                                                                                                                                                             |
 | [`@0x/contracts-exchange`](/contracts/exchange)                     | [![npm](https://img.shields.io/npm/v/@0x/contracts-exchange.svg)](https://www.npmjs.com/package/@0x/contracts-exchange)                     | The [`Exchange`](https://github.com/0xProject/0x-protocol-specification/blob/master/v2/v2-specification.md#exchange) contract used for settling trades within the protocol                                                                            |
 | [`@0x/contracts-exchange-forwarder`](/contracts/exchange-forwarder) | [![npm](https://img.shields.io/npm/v/@0x/contracts-exchange-forwarder.svg)](https://www.npmjs.com/package/@0x/contracts-exchange-forwarder) | A [`Forwarder`](https://github.com/0xProject/0x-protocol-specification/blob/master/v2/forwarder-specification.md) contract used to simplify UX for interacting with the protocol                                                                      |
-| [`@0x/contracts-exchange-libs`](/contracts/exchange-libs)           | [![npm](https://img.shields.io/npm/v/@0x/contracts-exchange-libs.svg)](https://www.npmjs.com/package/@0x/contracts-exchange-libs)           | Protocol specific Llbraries used within the [`Exchange`](https://github.com/0xProject/0x-protocol-specification/blob/master/v2/v2-specification.md#exchange) contract                                                                                 |
+| [`@0x/contracts-exchange-libs`](/contracts/exchange-libs)           | [![npm](https://img.shields.io/npm/v/@0x/contracts-exchange-libs.svg)](https://www.npmjs.com/package/@0x/contracts-exchange-libs)           | Protocol specific libraries used within the [`Exchange`](https://github.com/0xProject/0x-protocol-specification/blob/master/v2/v2-specification.md#exchange) contract                                                                                 |
 | [`@0x/contracts-extensions`](/contracts/extensions)                 | [![npm](https://img.shields.io/npm/v/@0x/contracts-extensions.svg)](https://www.npmjs.com/package/@0x/contracts-extensions)                 | Contracts that interact with and extend the functionality of the core protocol                                                                                                                                                                        |
 | [`@0x/contracts-multisig`](/contracts/multisig)                     | [![npm](https://img.shields.io/npm/v/@0x/contracts-multisig.svg)](https://www.npmjs.com/package/@0x/contracts-multisig)                     | Various implementations of multisignature wallets, including the [`AssetProxyOwner`](https://github.com/0xProject/0x-protocol-specification/blob/master/v2/v2-specification.md#assetproxyowner) contract that has permissions to upgrade the protocol |
 | [`@0x/contracts-test-utils`](/contracts/test-utils)                 | [![npm](https://img.shields.io/npm/v/@0x/contracts-test-utils.svg)](https://www.npmjs.com/package/@0x/contracts-test-utils)                 | Typescript/Javascript shared utilities used for testing contracts                                                                                                                                                                                     |
 | [`@0x/contracts-utils`](/contracts/utils)                           | [![npm](https://img.shields.io/npm/v/@0x/contracts-utils.svg)](https://www.npmjs.com/package/@0x/contracts-utils)                           | Generic libraries and utilities used throughout all of the contracts                                                                                                                                                                                  |
+| [`@0x/contracts-coordinator`](/contracts/coordinator)               | [![npm](https://img.shields.io/npm/v/@0x/contracts-coordinator.svg)](https://www.npmjs.com/package/@0x/contracts-coordinator)               | A contract that allows users to execute 0x transactions with permission from a Coordinator                                                                                                                                                            |
+| [`@0x/contracts-dev-utils`](/contracts/dev-utils)                   | [![npm](https://img.shields.io/npm/v/@0x/contracts-dev-utils.svg)](https://www.npmjs.com/package/@0x/contracts-dev-utils)                   | A contract contains utility functions for developers (such as validating many orders using a single eth_call)                                                                                                                                         |
 
 ### Typescript/Javascript Packages
 
@@ -65,6 +70,7 @@ Visit our [developer portal](https://0xproject.com/docs/order-utils) for a compr
 | [`@0x/sra-spec`](/packages/sra-spec)                     | [![npm](https://img.shields.io/npm/v/@0x/sra-spec.svg)](https://www.npmjs.com/package/@0x/sra-spec)                     | OpenAPI specification for the Standard Relayer API                                                |
 | [`@0x/connect`](/packages/connect)                       | [![npm](https://img.shields.io/npm/v/@0x/connect.svg)](https://www.npmjs.com/package/@0x/connect)                       | An HTTP/WS client for interacting with the Standard Relayer API                                   |
 | [`@0x/asset-buyer`](/packages/asset-buyer)               | [![npm](https://img.shields.io/npm/v/@0x/asset-buyer.svg)](https://www.npmjs.com/package/@0x/asset-buyer)               | Convenience package for discovering and buying assets with Ether                                  |
+| [`@0x/asset-swapper`](/packages/asset-swapper)           | [![npm](https://img.shields.io/npm/v/@0x/asset-swapper.svg)](https://www.npmjs.com/package/@0x/asset-swapper)           | Convenience package for discovering and performing swaps for any ERC20 Assets                     |
 
 #### Ethereum tooling
 
@@ -81,19 +87,17 @@ Visit our [developer portal](https://0xproject.com/docs/order-utils) for a compr
 
 #### Utilities
 
-| Package                                                  | Version                                                                                                                 | Description                                                                  |
-| -------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
-| [`@0x/abi-gen`](/packages/abi-gen)                       | [![npm](https://img.shields.io/npm/v/@0x/abi-gen.svg)](https://www.npmjs.com/package/@0x/abi-gen)                       | Tool to generate TS wrappers from smart contract ABIs                        |
-| [`@0x/tslint-config`](/packages/tslint-config)           | [![npm](https://img.shields.io/npm/v/@0x/tslint-config.svg)](https://www.npmjs.com/package/@0x/tslint-config)           | Custom TSLint rules used by the 0x core team                                 |
-| [`@0x/types`](/packages/types)                           | [![npm](https://img.shields.io/npm/v/@0x/types.svg)](https://www.npmjs.com/package/@0x/types)                           | Shared type declarations                                                     |
-| [`@0x/typescript-typings`](/packages/typescript-typings) | [![npm](https://img.shields.io/npm/v/@0x/typescript-typings.svg)](https://www.npmjs.com/package/@0x/typescript-typings) | Repository of types for external packages                                    |
-| [`@0x/utils`](/packages/utils)                           | [![npm](https://img.shields.io/npm/v/@0x/utils.svg)](https://www.npmjs.com/package/@0x/utils)                           | Shared utilities                                                             |
-| [`@0x/react-docs`](/packages/react-docs)                 | [![npm](https://img.shields.io/npm/v/@0x/react-docs.svg)](https://www.npmjs.com/package/@0x/react-docs)                 | React documentation component for rendering TypeDoc & sol-doc generated JSON |
-| [`@0x/react-shared`](/packages/react-shared)             | [![npm](https://img.shields.io/npm/v/@0x/react-shared.svg)](https://www.npmjs.com/package/@0x/react-shared)             | 0x shared react components                                                   |
-| [`@0x/assert`](/packages/assert)                         | [![npm](https://img.shields.io/npm/v/@0x/assert.svg)](https://www.npmjs.com/package/@0x/assert)                         | Type and schema assertions used by our packages                              |
-| [`@0x/base-contract`](/packages/base-contract)           | [![npm](https://img.shields.io/npm/v/@0x/base-contract.svg)](https://www.npmjs.com/package/@0x/base-contract)           | BaseContract used by auto-generated `abi-gen` wrapper contracts              |
-| [`@0x/dev-utils`](/packages/dev-utils)                   | [![npm](https://img.shields.io/npm/v/@0x/dev-utils.svg)](https://www.npmjs.com/package/@0x/dev-utils)                   | Dev utils to be shared across 0x packages                                    |
-| [`@0x/fill-scenarios`](/packages/fill-scenarios)         | [![npm](https://img.shields.io/npm/v/@0x/fill-scenarios.svg)](https://www.npmjs.com/package/@0x/fill-scenarios)         | 0x order fill scenario generator                                             |
+| Package                                                  | Version                                                                                                                 | Description                                                     |
+| -------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
+| [`@0x/abi-gen`](/packages/abi-gen)                       | [![npm](https://img.shields.io/npm/v/@0x/abi-gen.svg)](https://www.npmjs.com/package/@0x/abi-gen)                       | Tool to generate TS wrappers from smart contract ABIs           |
+| [`@0x/tslint-config`](/packages/tslint-config)           | [![npm](https://img.shields.io/npm/v/@0x/tslint-config.svg)](https://www.npmjs.com/package/@0x/tslint-config)           | Custom TSLint rules used by the 0x core team                    |
+| [`@0x/types`](/packages/types)                           | [![npm](https://img.shields.io/npm/v/@0x/types.svg)](https://www.npmjs.com/package/@0x/types)                           | Shared type declarations                                        |
+| [`@0x/typescript-typings`](/packages/typescript-typings) | [![npm](https://img.shields.io/npm/v/@0x/typescript-typings.svg)](https://www.npmjs.com/package/@0x/typescript-typings) | Repository of types for external packages                       |
+| [`@0x/utils`](/packages/utils)                           | [![npm](https://img.shields.io/npm/v/@0x/utils.svg)](https://www.npmjs.com/package/@0x/utils)                           | Shared utilities                                                |
+| [`@0x/assert`](/packages/assert)                         | [![npm](https://img.shields.io/npm/v/@0x/assert.svg)](https://www.npmjs.com/package/@0x/assert)                         | Type and schema assertions used by our packages                 |
+| [`@0x/base-contract`](/packages/base-contract)           | [![npm](https://img.shields.io/npm/v/@0x/base-contract.svg)](https://www.npmjs.com/package/@0x/base-contract)           | BaseContract used by auto-generated `abi-gen` wrapper contracts |
+| [`@0x/dev-utils`](/packages/dev-utils)                   | [![npm](https://img.shields.io/npm/v/@0x/dev-utils.svg)](https://www.npmjs.com/package/@0x/dev-utils)                   | Dev utils to be shared across 0x packages                       |
+| [`@0x/fill-scenarios`](/packages/fill-scenarios)         | [![npm](https://img.shields.io/npm/v/@0x/fill-scenarios.svg)](https://www.npmjs.com/package/@0x/fill-scenarios)         | 0x order fill scenario generator                                |
 
 #### Private Packages
 

contracts/README.md

@@ -0,0 +1,16 @@
+#### Deployed Contract Packages
+
+| Contract        | Package                                                             | Version                                                                          | Git Tag                                                                                                                                |
+| --------------- | ------------------------------------------------------------------- | -------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| AssetProxyOwner | [`@0x/contracts-multisig`](/contracts/multisig)                     | [v1.0.2](https://www.npmjs.com/package/@0x/contracts-multisig/v/1.0.2)           | [@0x/contracts-multisig@1.0.2](https://github.com/0xProject/0x-monorepo/releases/tag/@0x/contracts-multisig@1.0.2)                     |
+| ERC20Proxy      | [`@0x/contracts-asset-proxy`](/contracts/asset-proxy)               | [v1.0.1](https://www.npmjs.com/package/@0x/contracts-asset-proxy/v/1.0.1)        | [@0x/contracts-asset-proxy@1.0.1](https://github.com/0xProject/0x-monorepo/releases/tag/@0x/contracts-asset-proxy@1.0.1)               |
+| ERC721Proxy     | [`@0x/contracts-asset-proxy`](/contracts/asset-proxy)               | [v1.0.1](https://www.npmjs.com/package/@0x/contracts-asset-proxy/v/1.0.1)        | [@0x/contracts-asset-proxy@1.0.1](https://github.com/0xProject/0x-monorepo/releases/tag/@0x/contracts-asset-proxy@1.0.1)               |
+| Exchange        | [`@0x/contracts-exchange`](/contracts/exchange)                     | [v1.0.1](https://www.npmjs.com/package/@0x/contracts-exchange/v/1.0.1)           | [@0x/contracts-exchange@1.0.1](https://github.com/0xProject/0x-monorepo/releases/tag/@0x/contracts-exchange@1.0.1)                     |
+| DutchAuction    | [`@0x/contracts-extensions`](/contracts/extensions)                 | [v1.0.2](https://www.npmjs.com/package/@0x/contracts-extensions/v/1.0.2)         | [@0x/contracts-extensions@1.0.2](https://github.com/0xProject/0x-monorepo/releases/tag/@0x/contracts-extensions@1.0.2)                 |
+| Forwarder       | [`@0x/contracts-exchange-forwarder`](/contracts/exchange-forwarder) | [v1.0.1](https://www.npmjs.com/package/@0x/contracts-exchange-forwarder/v/1.0.1) | [@0x/contracts-exchange-forwarder@1.0.1](https://github.com/0xProject/0x-monorepo/releases/tag/@0x/contracts-exchange-forwarder@1.0.1) |
+| MultiAssetProxy | [`@0x/contracts-asset-proxy`](/contracts/asset-proxy)               | [v1.0.1](https://www.npmjs.com/package/@0x/contracts-asset-proxy/v/1.0.1)        | [@0x/contracts-asset-proxy@1.0.1](https://github.com/0xProject/0x-monorepo/releases/tag/@0x/contracts-asset-proxy@1.0.1)               |
+| ZRXToken        | [`@0x/contracts-erc20`](/contracts/erc20)                           | [v1.0.1](https://www.npmjs.com/package/@0x/contracts-erc20/v/1.0.1)              | [@0x/contracts-erc20@1.0.1](https://github.com/0xProject/0x-monorepo/releases/tag/@0x/contracts-erc20@1.0.1)                           |
+
+#### Development
+
+Building solidity files will update the contract artifact in `{package-name}/generated-artifacts/{contract}.json`, but does not automatically update the `abi-gen-wrappers` package, which are generated from the artifact JSON. To ensure consistency, clean and rebuild `abi-gen-wrappers` after any changes to the artifact JSON.

contracts/asset-proxy/CHANGELOG.json

@@ -1,4 +1,173 @@
 [
+    {
+        "version": "2.2.4",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564604963
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "2.2.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "2.2.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "2.2.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "2.2.0",
+        "changes": [
+            {
+                "note": "Add `LibAssetProxyIds` contract",
+                "pr": 1835
+            },
+            {
+                "note": "Updated ERC1155 Asset Proxy. Less optimization. More explicit handling of edge cases.",
+                "pr": 1852
+            },
+            {
+                "note": "Implement StaticCallProxy",
+                "pr": 1863
+            }
+        ],
+        "timestamp": 1563006338
+    },
+    {
+        "timestamp": 1558712885,
+        "version": "2.1.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1557961111,
+        "version": "2.1.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1557799313,
+        "version": "2.1.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "2.1.2",
+        "changes": [
+            {
+                "note": "Update tests to use contract-built-in `awaitTransactionSuccessAsync`",
+                "pr": 1797
+            }
+        ],
+        "timestamp": 1557507213
+    },
+    {
+        "version": "2.1.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ],
+        "timestamp": 1554997931
+    },
+    {
+        "version": "2.1.0",
+        "changes": [
+            {
+                "note": "Run Web3ProviderEngine without excess block polling",
+                "pr": 1695
+            }
+        ],
+        "timestamp": 1553183790
+    },
+    {
+        "version": "2.0.0",
+        "changes": [
+            {
+                "note": "Do not reexport external dependencies",
+                "pr": 1682
+            },
+            {
+                "note": "Add ERC1155Proxy",
+                "pr": 1661
+            },
+            {
+                "note": "Bumped solidity version to ^0.5.5",
+                "pr": 1701
+            },
+            {
+                "note": "Integration testing for ERC1155Proxy",
+                "pr": 1673
+            }
+        ],
+        "timestamp": 1553091633
+    },
+    {
+        "timestamp": 1551479279,
+        "version": "1.0.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1551299797,
+        "version": "1.0.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1551220833,
+        "version": "1.0.7",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1551130135,
+        "version": "1.0.6",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1549733923,
         "version": "1.0.5",

contracts/asset-proxy/CHANGELOG.md

@@ -5,6 +5,75 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v2.2.4 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v2.2.3 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v2.2.2 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v2.2.1 - _July 13, 2019_
+
+    * Dependencies updated
+
+## v2.2.0 - _July 13, 2019_
+
+    * Add `LibAssetProxyIds` contract (#1835)
+    * Updated ERC1155 Asset Proxy. Less optimization. More explicit handling of edge cases. (#1852)
+    * Implement StaticCallProxy (#1863)
+
+## v2.1.5 - _May 24, 2019_
+
+    * Dependencies updated
+
+## v2.1.4 - _May 15, 2019_
+
+    * Dependencies updated
+
+## v2.1.3 - _May 14, 2019_
+
+    * Dependencies updated
+
+## v2.1.2 - _May 10, 2019_
+
+    * Update tests to use contract-built-in `awaitTransactionSuccessAsync` (#1797)
+
+## v2.1.1 - _April 11, 2019_
+
+    * Dependencies updated
+
+## v2.1.0 - _March 21, 2019_
+
+    * Run Web3ProviderEngine without excess block polling (#1695)
+
+## v2.0.0 - _March 20, 2019_
+
+    * Do not reexport external dependencies (#1682)
+    * Add ERC1155Proxy (#1661)
+    * Bumped solidity version to ^0.5.5 (#1701)
+    * Integration testing for ERC1155Proxy (#1673)
+
+## v1.0.9 - _March 1, 2019_
+
+    * Dependencies updated
+
+## v1.0.8 - _February 27, 2019_
+
+    * Dependencies updated
+
+## v1.0.7 - _February 26, 2019_
+
+    * Dependencies updated
+
+## v1.0.6 - _February 25, 2019_
+
+    * Dependencies updated
+
 ## v1.0.5 - _February 9, 2019_
 
     * Dependencies updated

contracts/asset-proxy/compiler.json

@@ -1,13 +1,20 @@
 {
     "artifactsDir": "./generated-artifacts",
     "contractsDir": "./contracts",
-    "useDockerisedSolc": true,
+    "useDockerisedSolc": false,
+    "isOfflineMode": false,
     "compilerSettings": {
-        "optimizer": { "enabled": true, "runs": 1000000 },
+        "evmVersion": "constantinople",
+        "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",
@@ -17,17 +24,15 @@
         }
     },
     "contracts": [
-        "@0x/contracts-erc20/contracts/test/DummyERC20Token.sol",
-        "@0x/contracts-erc20/contracts/test/DummyMultipleReturnERC20Token.sol",
-        "@0x/contracts-erc20/contracts/test/DummyNoReturnERC20Token.sol",
-        "@0x/contracts-erc721/contracts/test/DummyERC721Receiver.sol",
-        "@0x/contracts-erc721/contracts/test/DummyERC721Token.sol",
+        "src/ERC1155Proxy.sol",
         "src/ERC20Proxy.sol",
         "src/ERC721Proxy.sol",
         "src/MixinAuthorizable.sol",
         "src/MultiAssetProxy.sol",
+        "src/StaticCallProxy.sol",
         "src/interfaces/IAssetData.sol",
         "src/interfaces/IAssetProxy.sol",
-        "src/interfaces/IAuthorizable.sol"
+        "src/interfaces/IAuthorizable.sol",
+        "test/TestStaticCallTarget.sol"
     ]
 }

contracts/asset-proxy/contracts/src/ERC1155Proxy.sol

@@ -0,0 +1,97 @@
+/*
+
+  Copyright 2018 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/LibBytes.sol";
+import "@0x/contracts-utils/contracts/src/SafeMath.sol";
+import "@0x/contracts-erc1155/contracts/src/interfaces/IERC1155.sol";
+import "./MixinAuthorizable.sol";
+import "./interfaces/IAssetProxy.sol";
+
+
+contract ERC1155Proxy is
+    MixinAuthorizable,
+    SafeMath,
+    IAssetProxy
+{
+    using LibBytes for bytes;
+
+    // Id of this proxy.
+    bytes4 constant internal PROXY_ID = bytes4(keccak256("ERC1155Assets(address,uint256[],uint256[],bytes)"));
+
+    /// @dev Transfers batch of ERC1155 assets. Either succeeds or throws.
+    /// @param assetData Byte array encoded with ERC1155 token address, array of ids, array of values, and callback data.
+    /// @param from Address to transfer assets from.
+    /// @param to Address to transfer assets to.
+    /// @param amount Amount that will be multiplied with each element of `assetData.values` to scale the
+    ///        values that will be transferred.
+    function transferFrom(
+        bytes calldata assetData,
+        address from,
+        address to,
+        uint256 amount
+    )
+        external
+        onlyAuthorized
+    {
+        // Decode params from `assetData`
+        // solhint-disable indent
+        (
+            address erc1155TokenAddress,
+            uint256[] memory ids,
+            uint256[] memory values,
+            bytes memory data
+        ) = abi.decode(
+            assetData.sliceDestructive(4, assetData.length),
+            (address, uint256[], uint256[], bytes)
+        );
+        // solhint-enable indent
+
+        // Scale values up by `amount`
+        uint256 length = values.length;
+        uint256[] memory scaledValues = new uint256[](length);
+        for (uint256 i = 0; i != length; i++) {
+            // We write the scaled values to an unused location in memory in order
+            // to avoid copying over `ids` or `data`. This is possible if they are
+            // identical to `values` and the offsets for each are pointing to the 
+            // same location in the ABI encoded calldata.
+            scaledValues[i] = safeMul(values[i], amount);
+        }
+
+        // Execute `safeBatchTransferFrom` call
+        // Either succeeds or throws
+        IERC1155(erc1155TokenAddress).safeBatchTransferFrom(
+            from,
+            to,
+            ids,
+            scaledValues,
+            data
+        );
+    }
+
+    /// @dev Gets the proxy id associated with the proxy address.
+    /// @return Proxy id.
+    function getProxyId()
+        external
+        pure
+        returns (bytes4)
+    {
+        return PROXY_ID;
+    }
+}

contracts/asset-proxy/contracts/src/ERC20Proxy.sol

@@ -16,7 +16,7 @@
 
 */
 
-pragma solidity 0.4.24;
+pragma solidity ^0.5.5;
 
 import "./MixinAuthorizable.sol";
 

contracts/asset-proxy/contracts/src/ERC721Proxy.sol

@@ -16,7 +16,7 @@
 
 */
 
-pragma solidity 0.4.24;
+pragma solidity ^0.5.5;
 
 import "./MixinAuthorizable.sol";
 

contracts/asset-proxy/contracts/src/MixinAssetProxyDispatcher.sol

@@ -16,7 +16,7 @@
 
 */
 
-pragma solidity ^0.4.24;
+pragma solidity ^0.5.5;
 
 import "@0x/contracts-utils/contracts/src/Ownable.sol";
 import "./mixins/MAssetProxyDispatcher.sol";
@@ -28,7 +28,7 @@ contract MixinAssetProxyDispatcher is
     MAssetProxyDispatcher
 {
     // Mapping from Asset Proxy Id's to their respective Asset Proxy
-    mapping (bytes4 => IAssetProxy) public assetProxies;
+    mapping (bytes4 => address) public assetProxies;
 
     /// @dev Registers an asset proxy to its asset proxy id.
     ///      Once an asset proxy is registered, it cannot be unregistered.
@@ -37,10 +37,8 @@ contract MixinAssetProxyDispatcher is
         external
         onlyOwner
     {
-        IAssetProxy assetProxyContract = IAssetProxy(assetProxy);
-
         // Ensure that no asset proxy exists with current id.
-        bytes4 assetProxyId = assetProxyContract.getProxyId();
+        bytes4 assetProxyId = IAssetProxy(assetProxy).getProxyId();
         address currentAssetProxy = assetProxies[assetProxyId];
         require(
             currentAssetProxy == address(0),
@@ -48,7 +46,7 @@ contract MixinAssetProxyDispatcher is
         );
 
         // Add asset proxy and log registration.
-        assetProxies[assetProxyId] = assetProxyContract;
+        assetProxies[assetProxyId] = assetProxy;
         emit AssetProxyRegistered(
             assetProxyId,
             assetProxy

contracts/asset-proxy/contracts/src/MixinAuthorizable.sol

@@ -16,7 +16,7 @@
 
 */
 
-pragma solidity ^0.4.24;
+pragma solidity ^0.5.5;
 
 import "@0x/contracts-utils/contracts/src/Ownable.sol";
 import "./mixins/MAuthorizable.sol";

contracts/asset-proxy/contracts/src/MultiAssetProxy.sol

@@ -16,7 +16,7 @@
 
 */
 
-pragma solidity 0.4.24;
+pragma solidity ^0.5.5;
 
 import "./MixinAssetProxyDispatcher.sol";
 import "./MixinAuthorizable.sol";
@@ -90,7 +90,10 @@ contract MultiAssetProxy is
                 //          offset to assetData.
 
                 // Load offset to `assetData`
-                let assetDataOffset := calldataload(4)
+                let assetDataOffset := add(calldataload(4), 4)
+
+                // Load length in bytes of `assetData`
+                let assetDataLength := calldataload(assetDataOffset)
 
                 // Asset data itself is encoded as follows:
                 //
@@ -108,41 +111,62 @@ contract MultiAssetProxy is
                 // |          | 132 + a     | b       | nestedAssetData Contents (offsets)  |
                 // |          | 132 + a + b |         | nestedAssetData[0, ..., len]        |
 
+                // Assert that the length of asset data:
+                // 1. Must be at least 68 bytes (see table above)
+                // 2. Must be a multiple of 32 (excluding the 4-byte selector)
+                if or(lt(assetDataLength, 68), mod(sub(assetDataLength, 4), 32)) {
+                    // Revert with `Error("INVALID_ASSET_DATA_LENGTH")`
+                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
+                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
+                    mstore(64, 0x00000019494e56414c49445f41535345545f444154415f4c454e475448000000)
+                    mstore(96, 0)
+                    revert(0, 100)
+                }
+
+                // End of asset data in calldata
+                // assetDataOffset
+                // + 32 (assetData len)
+                let assetDataEnd := add(assetDataOffset, add(assetDataLength, 32))
+                if gt(assetDataEnd, calldatasize()) {
+                    // Revert with `Error("INVALID_ASSET_DATA_END")`
+                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
+                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
+                    mstore(64, 0x00000016494e56414c49445f41535345545f444154415f454e44000000000000)
+                    mstore(96, 0)
+                    revert(0, 100)
+                }
+
                 // In order to find the offset to `amounts`, we must add:
-                // 4 (function selector)
-                // + assetDataOffset
+                // assetDataOffset
                 // + 32 (assetData len)
                 // + 4 (assetProxyId)
-                let amountsOffset := calldataload(add(assetDataOffset, 40))
+                let amountsOffset := calldataload(add(assetDataOffset, 36))
 
                 // In order to find the offset to `nestedAssetData`, we must add:
-                // 4 (function selector)
-                // + assetDataOffset
+                // assetDataOffset
                 // + 32 (assetData len)
                 // + 4 (assetProxyId)
                 // + 32 (amounts offset)
-                let nestedAssetDataOffset := calldataload(add(assetDataOffset, 72))
+                let nestedAssetDataOffset := calldataload(add(assetDataOffset, 68))
 
                 // In order to find the start of the `amounts` contents, we must add: 
-                // 4 (function selector) 
-                // + assetDataOffset 
+                // assetDataOffset 
                 // + 32 (assetData len)
                 // + 4 (assetProxyId)
                 // + amountsOffset
                 // + 32 (amounts len)
-                let amountsContentsStart := add(assetDataOffset, add(amountsOffset, 72))
+                let amountsContentsStart := add(assetDataOffset, add(amountsOffset, 68))
 
                 // Load number of elements in `amounts`
                 let amountsLen := calldataload(sub(amountsContentsStart, 32))
 
                 // In order to find the start of the `nestedAssetData` contents, we must add: 
-                // 4 (function selector) 
-                // + assetDataOffset 
+                // assetDataOffset 
                 // + 32 (assetData len)
                 // + 4 (assetProxyId)
                 // + nestedAssetDataOffset
                 // + 32 (nestedAssetData len)
-                let nestedAssetDataContentsStart := add(assetDataOffset, add(nestedAssetDataOffset, 72))
+                let nestedAssetDataContentsStart := add(assetDataOffset, add(nestedAssetDataOffset, 68))
 
                 // Load number of elements in `nestedAssetData`
                 let nestedAssetDataLen := calldataload(sub(nestedAssetDataContentsStart, 32))
@@ -204,15 +228,20 @@ contract MultiAssetProxy is
                     let nestedAssetDataElementOffset := calldataload(add(nestedAssetDataContentsStart, i))
 
                     // In order to find the start of the `nestedAssetData[i]` contents, we must add:
-                    // 4 (function selector) 
-                    // + assetDataOffset 
+                    // assetDataOffset 
                     // + 32 (assetData len)
                     // + 4 (assetProxyId)
                     // + nestedAssetDataOffset
                     // + 32 (nestedAssetData len)
                     // + nestedAssetDataElementOffset
                     // + 32 (nestedAssetDataElement len)
-                    let nestedAssetDataElementContentsStart := add(assetDataOffset, add(nestedAssetDataOffset, add(nestedAssetDataElementOffset, 104)))
+                    let nestedAssetDataElementContentsStart := add(
+                        assetDataOffset,
+                        add(
+                            nestedAssetDataOffset,
+                            add(nestedAssetDataElementOffset, 100)
+                        )
+                    )
 
                     // Load length of `nestedAssetData[i]`
                     let nestedAssetDataElementLenStart := sub(nestedAssetDataElementContentsStart, 32)

contracts/asset-proxy/contracts/src/StaticCallProxy.sol

@@ -0,0 +1,83 @@
+/*
+
+  Copyright 2018 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/LibBytes.sol";
+
+
+// solhint-disable no-unused-vars
+contract StaticCallProxy {
+
+    using LibBytes for bytes;
+
+    // Id of this proxy.
+    bytes4 constant internal PROXY_ID = bytes4(keccak256("StaticCall(address,bytes,bytes32)"));
+
+    /// @dev Makes a staticcall to a target address and verifies that the data returned matches the expected return data.
+    /// @param assetData Byte array encoded with staticCallTarget, staticCallData, and expectedCallResultHash
+    /// @param from This value is ignored.
+    /// @param to This value is ignored.
+    /// @param amount This value is ignored.
+    function transferFrom(
+        bytes calldata assetData,
+        address from,
+        address to,
+        uint256 amount
+    )
+        external
+        view
+    {
+        // Decode params from `assetData`
+        (
+            address staticCallTarget,
+            bytes memory staticCallData,
+            bytes32 expectedReturnDataHash
+        ) = abi.decode(
+            assetData.sliceDestructive(4, assetData.length),
+            (address, bytes, bytes32)
+        );
+
+        // Execute staticcall
+        (bool success, bytes memory returnData) = staticCallTarget.staticcall(staticCallData);
+
+        // Revert with returned data if staticcall is unsuccessful
+        if (!success) {
+            assembly {
+                revert(add(returnData, 32), mload(returnData))
+            }
+        }
+
+        // Revert if hash of return data is not as expected
+        bytes32 returnDataHash = keccak256(returnData);
+        require(
+            expectedReturnDataHash == returnDataHash,
+            "UNEXPECTED_STATIC_CALL_RESULT"
+        );
+    }
+
+    /// @dev Gets the proxy id associated with the proxy address.
+    /// @return Proxy id.
+    function getProxyId()
+        external
+        pure
+        returns (bytes4)
+    {
+        return PROXY_ID;
+    }
+}

contracts/asset-proxy/contracts/src/interfaces/IAssetData.sol

@@ -17,7 +17,7 @@
 */
 
 // solhint-disable
-pragma solidity ^0.4.24;
+pragma solidity ^0.5.5;
 pragma experimental ABIEncoderV2;
 
 
@@ -26,19 +26,33 @@ pragma experimental ABIEncoderV2;
 // This argument is ABI encoded as one of the methods of this interface.
 interface IAssetData {
 
-    function ERC20Token(address tokenContract)
+    function ERC20Token(address tokenAddress)
         external;
     
     function ERC721Token(
-        address tokenContract,
+        address tokenAddress,
         uint256 tokenId
     )
         external;
 
-    function MultiAsset(
-        uint256[] amounts,
-        bytes[] nestedAssetData
+    function ERC1155Assets(
+        address tokenAddress,
+        uint256[] calldata tokenIds,
+        uint256[] calldata tokenValues,
+        bytes calldata callbackData
+    )
+        external;
+
+    function MultiAsset(
+        uint256[] calldata amounts,
+        bytes[] calldata nestedAssetData
+    )
+        external;
+
+    function StaticCall(
+        address callTarget,
+        bytes calldata staticCallData,
+        bytes32 callResultHash
     )
         external;
-    
 }

contracts/asset-proxy/contracts/src/interfaces/IAssetProxy.sol

@@ -16,21 +16,20 @@
 
 */
 
-pragma solidity ^0.4.24;
+pragma solidity ^0.5.5;
 
 import "./IAuthorizable.sol";
 
 
-contract IAssetProxy is
-    IAuthorizable
-{
+contract IAssetProxy {
+
     /// @dev Transfers assets. Either succeeds or throws.
     /// @param assetData Byte array encoded for the respective asset proxy.
     /// @param from Address to transfer asset from.
     /// @param to Address to transfer asset to.
     /// @param amount Amount of asset to transfer.
     function transferFrom(
-        bytes assetData,
+        bytes calldata assetData,
         address from,
         address to,
         uint256 amount

contracts/asset-proxy/contracts/src/interfaces/IAssetProxyDispatcher.sol

@@ -16,7 +16,7 @@
 
 */
 
-pragma solidity ^0.4.24;
+pragma solidity ^0.5.5;
 
 
 contract IAssetProxyDispatcher {

contracts/asset-proxy/contracts/src/interfaces/IAuthorizable.sol

@@ -16,7 +16,7 @@
 
 */
 
-pragma solidity ^0.4.24;
+pragma solidity ^0.5.5;
 
 import "@0x/contracts-utils/contracts/src/interfaces/IOwnable.sol";
 

contracts/asset-proxy/contracts/src/libs/LibAssetProxyIds.sol

@@ -0,0 +1,40 @@
+/*
+
+  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;
+
+
+contract LibAssetProxyIds {
+
+    // AssetProxy Ids are equiavalent the first 4 bytes of the keccak256 hash of the function signature assigned to each AssetProxy.
+
+    // ERC20Token(address)
+    bytes4 constant public ERC20_PROXY_ID = 0xf47261b0;
+
+    // ERC721Token(address,uint256)
+    bytes4 constant public ERC721_PROXY_ID = 0x02571792;
+
+    // ERC1155Assets(address,uint256[],uint256[],bytes)
+    bytes4 constant public ERC1155_PROXY_ID = 0xa7cb5fb7;
+
+    // MultiAsset(uint256[],bytes[])
+    bytes4 constant public MULTI_ASSET_PROXY_ID = 0x94cfcdd7;
+
+    // StaticCall(address,bytes,bytes32)
+    bytes4 constant public STATIC_CALL_PROXY_ID = 0xc339d10a;
+}

contracts/asset-proxy/contracts/src/mixins/MAssetProxyDispatcher.sol

@@ -16,7 +16,7 @@
 
 */
 
-pragma solidity ^0.4.24;
+pragma solidity ^0.5.5;
 
 import "../interfaces/IAssetProxyDispatcher.sol";
 

contracts/asset-proxy/contracts/src/mixins/MAuthorizable.sol

@@ -16,7 +16,7 @@
 
 */
 
-pragma solidity ^0.4.24;
+pragma solidity ^0.5.5;
 
 import "../interfaces/IAuthorizable.sol";
 

contracts/asset-proxy/contracts/test/TestStaticCallTarget.sol

@@ -0,0 +1,82 @@
+/*
+
+  Copyright 2018 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/LibBytes.sol";
+
+
+contract TestStaticCallTarget {
+
+    using LibBytes for bytes;
+
+    uint256 internal _state;
+ 
+    function updateState()
+        external
+    {
+        _state++;
+    }
+
+    function assertEvenNumber(uint256 target)
+        external
+        pure
+    {
+        require(
+            target % 2 == 0,
+            "TARGET_NOT_EVEN"
+        );
+    }
+
+    function isOddNumber(uint256 target)
+        external
+        pure
+        returns (bool isOdd)
+    {
+        isOdd = target % 2 == 1;
+        return isOdd;
+    }
+
+    function noInputFunction()
+        external
+        pure
+    {
+        assert(msg.data.length == 4 && msg.data.readBytes4(0) == bytes4(keccak256("noInputFunction()")));
+    }
+
+    function dynamicInputFunction(bytes calldata a)
+        external
+        pure
+    {
+        bytes memory abiEncodedData = abi.encodeWithSignature("dynamicInputFunction(bytes)", a);
+        assert(msg.data.equals(abiEncodedData));
+    }
+
+    function returnComplexType(uint256 a, uint256 b)
+        external
+        view
+        returns (bytes memory result)
+    {
+        result = abi.encodePacked(
+            address(this),
+            a,
+            b
+        );
+        return result;
+    }
+}

contracts/asset-proxy/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-asset-proxy",
-    "version": "1.0.5",
+    "version": "2.2.4",
     "engines": {
         "node": ">=6.12"
     },
@@ -24,6 +24,7 @@
         "clean": "shx rm -rf lib generated-artifacts generated-wrappers",
         "generate_contract_wrappers": "abi-gen --abis  ${npm_package_config_abis} --template ../../node_modules/@0x/abi-gen-templates/contract.handlebars --partials '../../node_modules/@0x/abi-gen-templates/partials/**/*.handlebars' --output generated-wrappers --backend ethers",
         "lint": "tslint --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
+        "fix": "tslint --fix --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
         "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",
@@ -33,7 +34,7 @@
         "lint-contracts": "solhint -c ../.solhint.json contracts/**/**/**/**/*.sol"
     },
     "config": {
-        "abis": "./generated-artifacts/@(DummyERC20Token|DummyERC721Receiver|DummyERC721Token|DummyMultipleReturnERC20Token|DummyNoReturnERC20Token|ERC20Proxy|ERC721Proxy|IAssetData|IAssetProxy|IAuthorizable|MixinAuthorizable|MultiAssetProxy).json",
+        "abis": "./generated-artifacts/@(ERC1155Proxy|ERC20Proxy|ERC721Proxy|IAssetData|IAssetProxy|IAuthorizable|MixinAuthorizable|MultiAssetProxy|StaticCallProxy|TestStaticCallTarget).json",
         "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually."
     },
     "repository": {
@@ -46,19 +47,21 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/protocol/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.0.3",
-        "@0x/contracts-gen": "^1.0.2",
-        "@0x/dev-utils": "^2.1.0",
-        "@0x/sol-compiler": "^3.0.3",
-        "@0x/tslint-config": "^3.0.0",
+        "@0x/abi-gen": "^3.1.2",
+        "@0x/contracts-gen": "^1.0.12",
+        "@0x/contracts-test-utils": "^3.1.12",
+        "@0x/dev-utils": "^2.2.6",
+        "@0x/sol-compiler": "^3.1.11",
+        "@0x/tslint-config": "^3.0.1",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -66,17 +69,18 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^4.0.3",
-        "@0x/contracts-erc20": "1.0.2",
-        "@0x/contracts-erc721": "1.0.2",
-        "@0x/contracts-test-utils": "^3.0.4",
-        "@0x/contracts-utils": "2.0.1",
-        "@0x/order-utils": "^6.1.0",
-        "@0x/types": "^2.0.2",
-        "@0x/typescript-typings": "^4.0.0",
-        "@0x/utils": "^4.1.0",
-        "@0x/web3-wrapper": "^5.0.0",
-        "ethereum-types": "^2.0.0",
+        "@0x/base-contract": "^5.3.0",
+        "@0x/contracts-erc1155": "^1.1.11",
+        "@0x/contracts-erc20": "^2.2.10",
+        "@0x/contracts-erc721": "^2.1.11",
+        "@0x/contracts-utils": "^3.2.0",
+        "@0x/order-utils": "^8.2.4",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.4.2",
+        "@0x/web3-wrapper": "^6.0.9",
+        "ethereum-types": "^2.1.4",
+        "ethereumjs-util": "^5.1.1",
         "lodash": "^4.17.11"
     },
     "publishConfig": {

contracts/asset-proxy/src/artifacts.ts

@@ -5,11 +5,7 @@
  */
 import { ContractArtifact } from 'ethereum-types';
 
-import * as DummyERC20Token from '../generated-artifacts/DummyERC20Token.json';
-import * as DummyERC721Receiver from '../generated-artifacts/DummyERC721Receiver.json';
-import * as DummyERC721Token from '../generated-artifacts/DummyERC721Token.json';
-import * as DummyMultipleReturnERC20Token from '../generated-artifacts/DummyMultipleReturnERC20Token.json';
-import * as DummyNoReturnERC20Token from '../generated-artifacts/DummyNoReturnERC20Token.json';
+import * as ERC1155Proxy from '../generated-artifacts/ERC1155Proxy.json';
 import * as ERC20Proxy from '../generated-artifacts/ERC20Proxy.json';
 import * as ERC721Proxy from '../generated-artifacts/ERC721Proxy.json';
 import * as IAssetData from '../generated-artifacts/IAssetData.json';
@@ -17,17 +13,17 @@ import * as IAssetProxy from '../generated-artifacts/IAssetProxy.json';
 import * as IAuthorizable from '../generated-artifacts/IAuthorizable.json';
 import * as MixinAuthorizable from '../generated-artifacts/MixinAuthorizable.json';
 import * as MultiAssetProxy from '../generated-artifacts/MultiAssetProxy.json';
+import * as StaticCallProxy from '../generated-artifacts/StaticCallProxy.json';
+import * as TestStaticCallTarget from '../generated-artifacts/TestStaticCallTarget.json';
 export const artifacts = {
-    DummyERC20Token: DummyERC20Token as ContractArtifact,
-    DummyMultipleReturnERC20Token: DummyMultipleReturnERC20Token as ContractArtifact,
-    DummyNoReturnERC20Token: DummyNoReturnERC20Token as ContractArtifact,
-    DummyERC721Receiver: DummyERC721Receiver as ContractArtifact,
-    DummyERC721Token: DummyERC721Token as ContractArtifact,
+    ERC1155Proxy: ERC1155Proxy as ContractArtifact,
     ERC20Proxy: ERC20Proxy as ContractArtifact,
     ERC721Proxy: ERC721Proxy as ContractArtifact,
     MixinAuthorizable: MixinAuthorizable as ContractArtifact,
     MultiAssetProxy: MultiAssetProxy as ContractArtifact,
+    StaticCallProxy: StaticCallProxy as ContractArtifact,
     IAssetData: IAssetData as ContractArtifact,
     IAssetProxy: IAssetProxy as ContractArtifact,
     IAuthorizable: IAuthorizable as ContractArtifact,
+    TestStaticCallTarget: TestStaticCallTarget as ContractArtifact,
 };

contracts/asset-proxy/src/wrappers.ts

@@ -3,11 +3,7 @@
  * 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_erc721_receiver';
-export * from '../generated-wrappers/dummy_erc721_token';
-export * from '../generated-wrappers/dummy_multiple_return_erc20_token';
-export * from '../generated-wrappers/dummy_no_return_erc20_token';
+export * from '../generated-wrappers/erc1155_proxy';
 export * from '../generated-wrappers/erc20_proxy';
 export * from '../generated-wrappers/erc721_proxy';
 export * from '../generated-wrappers/i_asset_data';
@@ -15,3 +11,5 @@ export * from '../generated-wrappers/i_asset_proxy';
 export * from '../generated-wrappers/i_authorizable';
 export * from '../generated-wrappers/mixin_authorizable';
 export * from '../generated-wrappers/multi_asset_proxy';
+export * from '../generated-wrappers/static_call_proxy';
+export * from '../generated-wrappers/test_static_call_target';

contracts/asset-proxy/test/authorizable.ts

@@ -37,6 +37,7 @@ describe('Authorizable', () => {
             artifacts.MixinAuthorizable,
             provider,
             txDefaults,
+            artifacts,
         );
     });
     beforeEach(async () => {
@@ -53,16 +54,18 @@ describe('Authorizable', () => {
             );
         });
         it('should allow owner to add an authorized address', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
             const isAuthorized = await authorizable.authorized.callAsync(address);
             expect(isAuthorized).to.be.true();
         });
         it('should throw if owner attempts to authorize a duplicate address', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
             return expectTransactionFailedAsync(
@@ -74,8 +77,9 @@ describe('Authorizable', () => {
 
     describe('removeAuthorizedAddress', () => {
         it('should throw if not called by owner', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
             return expectTransactionFailedAsync(
@@ -87,14 +91,14 @@ describe('Authorizable', () => {
         });
 
         it('should allow owner to remove an authorized address', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.removeAuthorizedAddress.sendTransactionAsync(address, {
-                    from: owner,
-                }),
+            await authorizable.removeAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
             const isAuthorized = await authorizable.authorized.callAsync(address);
@@ -113,8 +117,9 @@ describe('Authorizable', () => {
 
     describe('removeAuthorizedAddressAtIndex', () => {
         it('should throw if not called by owner', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
             const index = new BigNumber(0);
@@ -126,8 +131,9 @@ describe('Authorizable', () => {
             );
         });
         it('should throw if index is >= authorities.length', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
             const index = new BigNumber(1);
@@ -150,12 +156,14 @@ describe('Authorizable', () => {
         it('should throw if address at index does not match target', async () => {
             const address1 = address;
             const address2 = notOwner;
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address1, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address1,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address2, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address2,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
             const address1Index = new BigNumber(0);
@@ -167,15 +175,16 @@ describe('Authorizable', () => {
             );
         });
         it('should allow owner to remove an authorized address', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
             const index = new BigNumber(0);
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.removeAuthorizedAddressAtIndex.sendTransactionAsync(address, index, {
-                    from: owner,
-                }),
+            await authorizable.removeAuthorizedAddressAtIndex.awaitTransactionSuccessAsync(
+                address,
+                index,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
             const isAuthorized = await authorizable.authorized.callAsync(address);
@@ -187,20 +196,17 @@ describe('Authorizable', () => {
         it('should return all authorized addresses', async () => {
             const initial = await authorizable.getAuthorizedAddresses.callAsync();
             expect(initial).to.have.length(0);
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, {
-                    from: owner,
-                }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
             const afterAdd = await authorizable.getAuthorizedAddresses.callAsync();
             expect(afterAdd).to.have.length(1);
             expect(afterAdd).to.include(address);
-
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.removeAuthorizedAddress.sendTransactionAsync(address, {
-                    from: owner,
-                }),
+            await authorizable.removeAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
             const afterRemove = await authorizable.getAuthorizedAddresses.callAsync();

contracts/asset-proxy/test/global_hooks.ts

@@ -1,8 +1,10 @@
 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', () => {
-    provider.start();
+    providerUtils.startProviderEngine(provider);
 });
 after('generate coverage report', async () => {
     if (env.parseBoolean(EnvVars.SolidityCoverage)) {

contracts/asset-proxy/test/proxies.ts

@@ -1,3 +1,16 @@
+import { ERC1155MintableContract, Erc1155Wrapper } from '@0x/contracts-erc1155';
+import {
+    artifacts as erc20Artifacts,
+    DummyERC20TokenContract,
+    DummyERC20TokenTransferEventArgs,
+    DummyMultipleReturnERC20TokenContract,
+    DummyNoReturnERC20TokenContract,
+} from '@0x/contracts-erc20';
+import {
+    artifacts as erc721Artifacts,
+    DummyERC721ReceiverContract,
+    DummyERC721TokenContract,
+} from '@0x/contracts-erc721';
 import {
     chaiSetup,
     constants,
@@ -10,7 +23,7 @@ import {
 } from '@0x/contracts-test-utils';
 import { BlockchainLifecycle } from '@0x/dev-utils';
 import { assetDataUtils } from '@0x/order-utils';
-import { RevertReason } from '@0x/types';
+import { AssetProxyId, RevertReason } from '@0x/types';
 import { BigNumber } from '@0x/utils';
 import * as chai from 'chai';
 import { LogWithDecodedArgs } from 'ethereum-types';
@@ -18,12 +31,8 @@ import * as _ from 'lodash';
 
 import {
     artifacts,
-    DummyERC20TokenContract,
-    DummyERC20TokenTransferEventArgs,
-    DummyERC721ReceiverContract,
-    DummyERC721TokenContract,
-    DummyMultipleReturnERC20TokenContract,
-    DummyNoReturnERC20TokenContract,
+    ERC1155ProxyContract,
+    ERC1155ProxyWrapper,
     ERC20ProxyContract,
     ERC20Wrapper,
     ERC721ProxyContract,
@@ -36,16 +45,8 @@ import {
 chaiSetup.configure();
 const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
-const assetProxyInterface = new IAssetProxyContract(
-    artifacts.IAssetProxy.compilerOutput.abi,
-    constants.NULL_ADDRESS,
-    provider,
-);
-const assetDataInterface = new IAssetDataContract(
-    artifacts.IAssetData.compilerOutput.abi,
-    constants.NULL_ADDRESS,
-    provider,
-);
+const assetProxyInterface = new IAssetProxyContract(constants.NULL_ADDRESS, provider);
+const assetDataInterface = new IAssetDataContract(constants.NULL_ADDRESS, provider);
 
 // tslint:disable:no-unnecessary-type-assertion
 describe('Asset Transfer Proxies', () => {
@@ -71,6 +72,15 @@ describe('Asset Transfer Proxies', () => {
     let erc721AFromTokenId: BigNumber;
     let erc721BFromTokenId: BigNumber;
 
+    let erc1155Proxy: ERC1155ProxyContract;
+    let erc1155ProxyWrapper: ERC1155ProxyWrapper;
+    let erc1155Contract: ERC1155MintableContract;
+    let erc1155Contract2: ERC1155MintableContract;
+    let erc1155Wrapper: Erc1155Wrapper;
+    let erc1155Wrapper2: Erc1155Wrapper;
+    let erc1155FungibleTokens: BigNumber[];
+    let erc1155NonFungibleTokensOwnedBySpender: BigNumber[];
+
     before(async () => {
         await blockchainLifecycle.startAsync();
     });
@@ -91,53 +101,66 @@ describe('Asset Transfer Proxies', () => {
             artifacts.MultiAssetProxy,
             provider,
             txDefaults,
+            artifacts,
         );
 
         // Configure ERC20Proxy
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await erc20Proxy.addAuthorizedAddress.sendTransactionAsync(authorized, {
-                from: owner,
-            }),
+        await erc20Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
+            authorized,
+            { from: owner },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await erc20Proxy.addAuthorizedAddress.sendTransactionAsync(multiAssetProxy.address, {
-                from: owner,
-            }),
+        await erc20Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
+            multiAssetProxy.address,
+            { from: owner },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
 
         // Configure ERC721Proxy
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await erc721Proxy.addAuthorizedAddress.sendTransactionAsync(authorized, {
-                from: owner,
-            }),
+        await erc721Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
+            authorized,
+            { from: owner },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await erc721Proxy.addAuthorizedAddress.sendTransactionAsync(multiAssetProxy.address, {
-                from: owner,
-            }),
+        await erc721Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
+            multiAssetProxy.address,
+            { from: owner },
+            constants.AWAIT_TRANSACTION_MINED_MS,
+        );
+
+        // Configure ERC115Proxy
+        erc1155ProxyWrapper = new ERC1155ProxyWrapper(provider, usedAddresses, owner);
+        erc1155Proxy = await erc1155ProxyWrapper.deployProxyAsync();
+        await erc1155Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
+            authorized,
+            { from: owner },
+            constants.AWAIT_TRANSACTION_MINED_MS,
+        );
+        await erc1155Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
+            multiAssetProxy.address,
+            { from: owner },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
 
         // Configure MultiAssetProxy
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await multiAssetProxy.addAuthorizedAddress.sendTransactionAsync(authorized, {
-                from: owner,
-            }),
+        await multiAssetProxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
+            authorized,
+            { from: owner },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await multiAssetProxy.registerAssetProxy.sendTransactionAsync(erc20Proxy.address, {
-                from: owner,
-            }),
+        await multiAssetProxy.registerAssetProxy.awaitTransactionSuccessAsync(
+            erc20Proxy.address,
+            { from: owner },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await multiAssetProxy.registerAssetProxy.sendTransactionAsync(erc721Proxy.address, {
-                from: owner,
-            }),
+        await multiAssetProxy.registerAssetProxy.awaitTransactionSuccessAsync(
+            erc721Proxy.address,
+            { from: owner },
+            constants.AWAIT_TRANSACTION_MINED_MS,
+        );
+        await multiAssetProxy.registerAssetProxy.awaitTransactionSuccessAsync(
+            erc1155Proxy.address,
+            { from: owner },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
 
@@ -148,18 +171,20 @@ describe('Asset Transfer Proxies', () => {
             constants.DUMMY_TOKEN_DECIMALS,
         );
         noReturnErc20Token = await DummyNoReturnERC20TokenContract.deployFrom0xArtifactAsync(
-            artifacts.DummyNoReturnERC20Token,
+            erc20Artifacts.DummyNoReturnERC20Token,
             provider,
             txDefaults,
+            artifacts,
             constants.DUMMY_TOKEN_NAME,
             constants.DUMMY_TOKEN_SYMBOL,
             constants.DUMMY_TOKEN_DECIMALS,
             constants.DUMMY_TOKEN_TOTAL_SUPPLY,
         );
         multipleReturnErc20Token = await DummyMultipleReturnERC20TokenContract.deployFrom0xArtifactAsync(
-            artifacts.DummyMultipleReturnERC20Token,
+            erc20Artifacts.DummyMultipleReturnERC20Token,
             provider,
             txDefaults,
+            artifacts,
             constants.DUMMY_TOKEN_NAME,
             constants.DUMMY_TOKEN_SYMBOL,
             constants.DUMMY_TOKEN_DECIMALS,
@@ -167,46 +192,64 @@ describe('Asset Transfer Proxies', () => {
         );
 
         await erc20Wrapper.setBalancesAndAllowancesAsync();
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await noReturnErc20Token.setBalance.sendTransactionAsync(fromAddress, constants.INITIAL_ERC20_BALANCE),
+        await noReturnErc20Token.setBalance.awaitTransactionSuccessAsync(
+            fromAddress,
+            constants.INITIAL_ERC20_BALANCE,
+            {
+                from: owner,
+            },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await noReturnErc20Token.approve.sendTransactionAsync(
-                erc20Proxy.address,
-                constants.INITIAL_ERC20_ALLOWANCE,
-                { from: fromAddress },
-            ),
+        await noReturnErc20Token.approve.awaitTransactionSuccessAsync(
+            erc20Proxy.address,
+            constants.INITIAL_ERC20_ALLOWANCE,
+            { from: fromAddress },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await multipleReturnErc20Token.setBalance.sendTransactionAsync(
-                fromAddress,
-                constants.INITIAL_ERC20_BALANCE,
-            ),
+        await multipleReturnErc20Token.setBalance.awaitTransactionSuccessAsync(
+            fromAddress,
+            constants.INITIAL_ERC20_BALANCE,
+            {
+                from: owner,
+            },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await multipleReturnErc20Token.approve.sendTransactionAsync(
-                erc20Proxy.address,
-                constants.INITIAL_ERC20_ALLOWANCE,
-                { from: fromAddress },
-            ),
+        await multipleReturnErc20Token.approve.awaitTransactionSuccessAsync(
+            erc20Proxy.address,
+            constants.INITIAL_ERC20_ALLOWANCE,
+            { from: fromAddress },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
 
         // Deploy and configure ERC721 tokens and receiver
         [erc721TokenA, erc721TokenB] = await erc721Wrapper.deployDummyTokensAsync();
         erc721Receiver = await DummyERC721ReceiverContract.deployFrom0xArtifactAsync(
-            artifacts.DummyERC721Receiver,
+            erc721Artifacts.DummyERC721Receiver,
             provider,
             txDefaults,
+            artifacts,
         );
 
         await erc721Wrapper.setBalancesAndAllowancesAsync();
         const erc721Balances = await erc721Wrapper.getBalancesAsync();
         erc721AFromTokenId = erc721Balances[fromAddress][erc721TokenA.address][0];
         erc721BFromTokenId = erc721Balances[fromAddress][erc721TokenB.address][0];
+
+        // Deploy & configure ERC1155 tokens and receiver
+        [erc1155Wrapper, erc1155Wrapper2] = await erc1155ProxyWrapper.deployDummyContractsAsync();
+        erc1155Contract = erc1155Wrapper.getContract();
+        erc1155Contract2 = erc1155Wrapper2.getContract();
+        await erc1155ProxyWrapper.setBalancesAndAllowancesAsync();
+        erc1155FungibleTokens = erc1155ProxyWrapper.getFungibleTokenIds();
+        const nonFungibleTokens = erc1155ProxyWrapper.getNonFungibleTokenIds();
+        const tokenBalances = await erc1155ProxyWrapper.getBalancesAsync();
+        erc1155NonFungibleTokensOwnedBySpender = [];
+        _.each(nonFungibleTokens, (nonFungibleToken: BigNumber) => {
+            const nonFungibleTokenAsString = nonFungibleToken.toString();
+            const nonFungibleTokenHeldBySpender =
+                tokenBalances.nonFungible[fromAddress][erc1155Contract.address][nonFungibleTokenAsString][0];
+            erc1155NonFungibleTokensOwnedBySpender.push(nonFungibleTokenHeldBySpender);
+        });
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
@@ -364,10 +407,10 @@ describe('Asset Transfer Proxies', () => {
                     toAddress,
                     amount,
                 );
-                await web3Wrapper.awaitTransactionSuccessAsync(
-                    await erc20TokenA.approve.sendTransactionAsync(erc20Proxy.address, allowance, {
-                        from: fromAddress,
-                    }),
+                await erc20TokenA.approve.awaitTransactionSuccessAsync(
+                    erc20Proxy.address,
+                    allowance,
+                    { from: fromAddress },
                     constants.AWAIT_TRANSACTION_MINED_MS,
                 );
                 const erc20Balances = await erc20Wrapper.getBalancesAsync();
@@ -396,10 +439,10 @@ describe('Asset Transfer Proxies', () => {
                     toAddress,
                     amount,
                 );
-                await web3Wrapper.awaitTransactionSuccessAsync(
-                    await noReturnErc20Token.approve.sendTransactionAsync(erc20Proxy.address, allowance, {
-                        from: fromAddress,
-                    }),
+                await noReturnErc20Token.approve.awaitTransactionSuccessAsync(
+                    erc20Proxy.address,
+                    allowance,
+                    { from: fromAddress },
                     constants.AWAIT_TRANSACTION_MINED_MS,
                 );
                 const initialFromBalance = await noReturnErc20Token.balanceOf.callAsync(fromAddress);
@@ -562,7 +605,7 @@ describe('Asset Transfer Proxies', () => {
                     erc721Receiver.address,
                     amount,
                 );
-                const logDecoder = new LogDecoder(web3Wrapper, artifacts);
+                const logDecoder = new LogDecoder(web3Wrapper, { ...artifacts, ...erc721Artifacts });
                 const tx = await logDecoder.getTxWithDecodedLogsAsync(
                     await web3Wrapper.sendTransactionAsync({
                         to: erc721Proxy.address,
@@ -637,10 +680,10 @@ describe('Asset Transfer Proxies', () => {
                 const ownerFromAsset = await erc721TokenA.ownerOf.callAsync(erc721AFromTokenId);
                 expect(ownerFromAsset).to.be.equal(fromAddress);
                 // Remove transfer approval for fromAddress.
-                await web3Wrapper.awaitTransactionSuccessAsync(
-                    await erc721TokenA.approve.sendTransactionAsync(constants.NULL_ADDRESS, erc721AFromTokenId, {
-                        from: fromAddress,
-                    }),
+                await erc721TokenA.approve.awaitTransactionSuccessAsync(
+                    constants.NULL_ADDRESS,
+                    erc721AFromTokenId,
+                    { from: fromAddress },
                     constants.AWAIT_TRANSACTION_MINED_MS,
                 );
                 // Perform a transfer; expect this to fail.
@@ -754,7 +797,7 @@ describe('Asset Transfer Proxies', () => {
                     inputAmount,
                 );
                 const erc20Balances = await erc20Wrapper.getBalancesAsync();
-                const logDecoder = new LogDecoder(web3Wrapper, artifacts);
+                const logDecoder = new LogDecoder(web3Wrapper, { ...artifacts, ...erc20Artifacts });
                 const tx = await logDecoder.getTxWithDecodedLogsAsync(
                     await web3Wrapper.sendTransactionAsync({
                         to: multiAssetProxy.address,
@@ -938,6 +981,314 @@ describe('Asset Transfer Proxies', () => {
                 expect(newOwnerFromAsset1).to.be.equal(toAddress);
                 expect(newOwnerFromAsset2).to.be.equal(toAddress);
             });
+            it('should transfer a fungible ERC1155 token', async () => {
+                // setup test parameters
+                const tokenHolders = [fromAddress, toAddress];
+                const tokensToTransfer = erc1155FungibleTokens.slice(0, 1);
+                const valuesToTransfer = [new BigNumber(25)];
+                const valueMultiplier = new BigNumber(23);
+                const receiverCallbackData = '0x0102030405';
+                // check balances before transfer
+                const expectedInitialBalances = [
+                    // from
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                    // to
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                ];
+                await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
+                // encode erc1155 asset data
+                const erc1155AssetData = assetDataUtils.encodeERC1155AssetData(
+                    erc1155Contract.address,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                );
+                // encode multi-asset data
+                const multiAssetAmount = new BigNumber(5);
+                const amounts = [valueMultiplier];
+                const nestedAssetData = [erc1155AssetData];
+                const assetData = assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetData,
+                    fromAddress,
+                    toAddress,
+                    multiAssetAmount,
+                );
+                // execute transfer
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data,
+                        from: authorized,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                // check balances
+                const totalValueTransferred = valuesToTransfer[0].times(valueMultiplier).times(multiAssetAmount);
+                const expectedFinalBalances = [
+                    // from
+                    expectedInitialBalances[0].minus(totalValueTransferred),
+                    // to
+                    expectedInitialBalances[1].plus(totalValueTransferred),
+                ];
+                await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedFinalBalances);
+            });
+            it('should successfully transfer multiple fungible tokens of the same ERC1155 contract', async () => {
+                // setup test parameters
+                const tokenHolders = [fromAddress, toAddress];
+                const tokensToTransfer = erc1155FungibleTokens.slice(0, 3);
+                const valuesToTransfer = [new BigNumber(25), new BigNumber(35), new BigNumber(45)];
+                const valueMultiplier = new BigNumber(23);
+                const receiverCallbackData = '0x0102030405';
+                // check balances before transfer
+                const expectedInitialBalances = [
+                    // from
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                    // to
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                ];
+                await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
+                // encode erc1155 asset data
+                const erc1155AssetData = assetDataUtils.encodeERC1155AssetData(
+                    erc1155Contract.address,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                );
+                // encode multi-asset data
+                const multiAssetAmount = new BigNumber(5);
+                const amounts = [valueMultiplier];
+                const nestedAssetData = [erc1155AssetData];
+                const assetData = assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetData,
+                    fromAddress,
+                    toAddress,
+                    multiAssetAmount,
+                );
+                // execute transfer
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data,
+                        from: authorized,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                // check balances
+                const totalValuesTransferred = _.map(valuesToTransfer, (value: BigNumber) => {
+                    return value.times(valueMultiplier).times(multiAssetAmount);
+                });
+                const expectedFinalBalances = [
+                    // from
+                    expectedInitialBalances[0].minus(totalValuesTransferred[0]),
+                    expectedInitialBalances[1].minus(totalValuesTransferred[1]),
+                    expectedInitialBalances[2].minus(totalValuesTransferred[2]),
+                    // to
+                    expectedInitialBalances[3].plus(totalValuesTransferred[0]),
+                    expectedInitialBalances[4].plus(totalValuesTransferred[1]),
+                    expectedInitialBalances[5].plus(totalValuesTransferred[2]),
+                ];
+                await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedFinalBalances);
+            });
+            it('should successfully transfer multiple fungible/non-fungible tokens of the same ERC1155 contract', async () => {
+                // setup test parameters
+                const tokenHolders = [fromAddress, toAddress];
+                const fungibleTokensToTransfer = erc1155FungibleTokens.slice(0, 1);
+                const nonFungibleTokensToTransfer = erc1155NonFungibleTokensOwnedBySpender.slice(0, 1);
+                const tokensToTransfer = fungibleTokensToTransfer.concat(nonFungibleTokensToTransfer);
+                const valuesToTransfer = [new BigNumber(25), new BigNumber(1)];
+                const valueMultiplier = new BigNumber(1);
+                const receiverCallbackData = '0x0102030405';
+                // check balances before transfer
+                const nftOwnerBalance = new BigNumber(1);
+                const nftNotOwnerBalance = new BigNumber(0);
+                const expectedInitialBalances = [
+                    // from
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                    nftOwnerBalance,
+                    // to
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                    nftNotOwnerBalance,
+                ];
+                await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
+                // encode erc1155 asset data
+                const erc1155AssetData = assetDataUtils.encodeERC1155AssetData(
+                    erc1155Contract.address,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                );
+                // encode multi-asset data
+                const multiAssetAmount = new BigNumber(1);
+                const amounts = [valueMultiplier];
+                const nestedAssetData = [erc1155AssetData];
+                const assetData = assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetData,
+                    fromAddress,
+                    toAddress,
+                    multiAssetAmount,
+                );
+                // execute transfer
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data,
+                        from: authorized,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                // check balances
+                const totalValuesTransferred = _.map(valuesToTransfer, (value: BigNumber) => {
+                    return value.times(valueMultiplier).times(multiAssetAmount);
+                });
+                const expectedFinalBalances = [
+                    // from
+                    expectedInitialBalances[0].minus(totalValuesTransferred[0]),
+                    expectedInitialBalances[1].minus(totalValuesTransferred[1]),
+                    // to
+                    expectedInitialBalances[2].plus(totalValuesTransferred[0]),
+                    expectedInitialBalances[3].plus(totalValuesTransferred[1]),
+                ];
+                await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedFinalBalances);
+            });
+            it('should successfully transfer multiple different ERC1155 tokens', async () => {
+                // setup test parameters
+                const tokenHolders = [fromAddress, toAddress];
+                const tokensToTransfer = erc1155FungibleTokens.slice(0, 1);
+                const valuesToTransfer = [new BigNumber(25)];
+                const valueMultiplier = new BigNumber(23);
+                const receiverCallbackData = '0x0102030405';
+                // check balances before transfer
+                const expectedInitialBalances = [
+                    // from
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                    // to
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                ];
+                await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
+                await erc1155Wrapper2.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedInitialBalances);
+                // encode erc1155 asset data
+                const erc1155AssetData1 = assetDataUtils.encodeERC1155AssetData(
+                    erc1155Contract.address,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                );
+                const erc1155AssetData2 = assetDataUtils.encodeERC1155AssetData(
+                    erc1155Contract2.address,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                );
+                // encode multi-asset data
+                const multiAssetAmount = new BigNumber(5);
+                const amounts = [valueMultiplier, valueMultiplier];
+                const nestedAssetData = [erc1155AssetData1, erc1155AssetData2];
+                const assetData = assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetData,
+                    fromAddress,
+                    toAddress,
+                    multiAssetAmount,
+                );
+                // execute transfer
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data,
+                        from: authorized,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                // check balances
+                const totalValueTransferred = valuesToTransfer[0].times(valueMultiplier).times(multiAssetAmount);
+                const expectedFinalBalances = [
+                    // from
+                    expectedInitialBalances[0].minus(totalValueTransferred),
+                    // to
+                    expectedInitialBalances[1].plus(totalValueTransferred),
+                ];
+                await erc1155Wrapper.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedFinalBalances);
+                await erc1155Wrapper2.assertBalancesAsync(tokenHolders, tokensToTransfer, expectedFinalBalances);
+            });
+            it('should successfully transfer a combination of ERC20, ERC721, and ERC1155 tokens', async () => {
+                // setup test parameters
+                const inputAmount = new BigNumber(1);
+                const erc20Amount = new BigNumber(10);
+                const erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20TokenA.address);
+                const erc721Amount = new BigNumber(1);
+                const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721TokenA.address, erc721AFromTokenId);
+                const erc1155TokenHolders = [fromAddress, toAddress];
+                const erc1155TokensToTransfer = erc1155FungibleTokens.slice(0, 1);
+                const erc1155ValuesToTransfer = [new BigNumber(25)];
+                const erc1155Amount = new BigNumber(23);
+                const erc1155ReceiverCallbackData = '0x0102030405';
+                const erc1155AssetData = assetDataUtils.encodeERC1155AssetData(
+                    erc1155Contract.address,
+                    erc1155TokensToTransfer,
+                    erc1155ValuesToTransfer,
+                    erc1155ReceiverCallbackData,
+                );
+                const amounts = [erc20Amount, erc721Amount, erc1155Amount];
+                const nestedAssetData = [erc20AssetData, erc721AssetData, erc1155AssetData];
+                const assetData = assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetData,
+                    fromAddress,
+                    toAddress,
+                    inputAmount,
+                );
+                // check balances before transfer
+                const erc20Balances = await erc20Wrapper.getBalancesAsync();
+                const ownerFromAsset = await erc721TokenA.ownerOf.callAsync(erc721AFromTokenId);
+                expect(ownerFromAsset).to.be.equal(fromAddress);
+                const erc1155ExpectedInitialBalances = [
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                ];
+                await erc1155Wrapper.assertBalancesAsync(
+                    erc1155TokenHolders,
+                    erc1155TokensToTransfer,
+                    erc1155ExpectedInitialBalances,
+                );
+                // execute transfer
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data,
+                        from: authorized,
+                        gas: 1000000,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                // check balances after transfer
+                const newBalances = await erc20Wrapper.getBalancesAsync();
+                const totalAmount = inputAmount.times(erc20Amount);
+                expect(newBalances[fromAddress][erc20TokenA.address]).to.be.bignumber.equal(
+                    erc20Balances[fromAddress][erc20TokenA.address].minus(totalAmount),
+                );
+                expect(newBalances[toAddress][erc20TokenA.address]).to.be.bignumber.equal(
+                    erc20Balances[toAddress][erc20TokenA.address].plus(totalAmount),
+                );
+                const newOwnerFromAsset = await erc721TokenA.ownerOf.callAsync(erc721AFromTokenId);
+                expect(newOwnerFromAsset).to.be.equal(toAddress);
+                const erc1155TotalValueTransferred = erc1155ValuesToTransfer[0].times(erc1155Amount).times(inputAmount);
+                const expectedFinalBalances = [
+                    erc1155ExpectedInitialBalances[0].minus(erc1155TotalValueTransferred),
+                    erc1155ExpectedInitialBalances[1].plus(erc1155TotalValueTransferred),
+                ];
+                await erc1155Wrapper.assertBalancesAsync(
+                    erc1155TokenHolders,
+                    erc1155TokensToTransfer,
+                    expectedFinalBalances,
+                );
+            });
             it('should successfully transfer a combination of ERC20 and ERC721 tokens', async () => {
                 const inputAmount = new BigNumber(1);
                 const erc20Amount = new BigNumber(10);
@@ -983,7 +1334,7 @@ describe('Asset Transfer Proxies', () => {
                 const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721TokenA.address, erc721AFromTokenId);
                 const amounts = [erc20Amount, erc721Amount];
                 const nestedAssetData = [erc20AssetData, erc721AssetData];
-                const extraData = '0102030405060708';
+                const extraData = '0102030405060708090001020304050607080900010203040506070809000102';
                 const assetData = `${assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData)}${extraData}`;
                 const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
                     assetData,
@@ -1278,6 +1629,120 @@ describe('Asset Transfer Proxies', () => {
                     RevertReason.SenderNotAuthorized,
                 );
             });
+            it('should revert if asset data overflows beyond the bounds of calldata', async () => {
+                const inputAmount = new BigNumber(1);
+                const erc20Amount = new BigNumber(10);
+                const erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20TokenA.address);
+                const erc721Amount = new BigNumber(1);
+                const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721TokenA.address, erc721AFromTokenId);
+                const amounts = [erc20Amount, erc721Amount];
+                const nestedAssetData = [erc20AssetData, erc721AssetData];
+                const assetData = assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetData,
+                    fromAddress,
+                    toAddress,
+                    inputAmount,
+                );
+                // append asset data to end of tx data with a length of 0x300 bytes, which will extend past actual calldata.
+                const offsetToAssetData = '0000000000000000000000000000000000000000000000000000000000000080';
+                const invalidOffsetToAssetData = '00000000000000000000000000000000000000000000000000000000000002a0';
+                const newAssetData = '0000000000000000000000000000000000000000000000000000000000000304';
+                const badData = `${data.replace(offsetToAssetData, invalidOffsetToAssetData)}${newAssetData}`;
+                // execute transfer
+                await expectTransactionFailedAsync(
+                    web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data: badData,
+                        from: authorized,
+                    }),
+                    RevertReason.InvalidAssetDataEnd,
+                );
+            });
+            it('should revert if asset data resolves to a location beyond the bounds of calldata', async () => {
+                const inputAmount = new BigNumber(1);
+                const erc20Amount = new BigNumber(10);
+                const erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20TokenA.address);
+                const erc721Amount = new BigNumber(1);
+                const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721TokenA.address, erc721AFromTokenId);
+                const amounts = [erc20Amount, erc721Amount];
+                const nestedAssetData = [erc20AssetData, erc721AssetData];
+                const assetData = assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetData,
+                    fromAddress,
+                    toAddress,
+                    inputAmount,
+                );
+                const offsetToAssetData = '0000000000000000000000000000000000000000000000000000000000000080';
+                const invalidOffsetToAssetData = '0000000000000000000000000000000000000000000000000000000000000400';
+                const badData = data.replace(offsetToAssetData, invalidOffsetToAssetData);
+                // execute transfer
+                // note that this triggers `InvalidAssetDataLength` because the length is zero, otherwise it would
+                // trigger `InvalidAssetDataEnd`.
+                await expectTransactionFailedAsync(
+                    web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data: badData,
+                        from: authorized,
+                    }),
+                    RevertReason.InvalidAssetDataLength,
+                );
+            });
+            it('should revert if length of assetData, excluding the selector, is not a multiple of 32', async () => {
+                // setup test parameters
+                const inputAmount = new BigNumber(1);
+                const erc20Amount = new BigNumber(10);
+                const erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20TokenA.address);
+                const erc721Amount = new BigNumber(1);
+                const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721TokenA.address, erc721AFromTokenId);
+                const amounts = [erc20Amount, erc721Amount];
+                const nestedAssetData = [erc20AssetData, erc721AssetData];
+                const assetData = assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData);
+                const extraData = '01';
+                const assetDataWithExtraData = `${assetData}${extraData}`;
+                const badData = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetDataWithExtraData,
+                    fromAddress,
+                    toAddress,
+                    inputAmount,
+                );
+                // execute transfer
+                await expectTransactionFailedAsync(
+                    web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data: badData,
+                        from: authorized,
+                    }),
+                    RevertReason.InvalidAssetDataLength,
+                );
+            });
+            it('should revert if length of assetData is less than 68 bytes', async () => {
+                // setup test parameters
+                const inputAmount = new BigNumber(1);
+                // we'll construct asset data that has a 4 byte selector plus
+                // 32 byte payload. This results in asset data that is 36 bytes
+                // long and will trigger the `invalid length` error.
+                // we must be sure to use a # of bytes that is still %32
+                // so that we know the error is not triggered by another check in the code.
+                const zeros32Bytes = '0'.repeat(64);
+                const assetData36Bytes = `${AssetProxyId.MultiAsset}${zeros32Bytes}`;
+                const badData = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetData36Bytes,
+                    fromAddress,
+                    toAddress,
+                    inputAmount,
+                );
+                // execute transfer
+                await expectTransactionFailedAsync(
+                    web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data: badData,
+                        from: authorized,
+                    }),
+                    RevertReason.InvalidAssetDataLength,
+                );
+            });
         });
     });
 });

contracts/asset-proxy/test/static_call_proxy.ts

@@ -0,0 +1,242 @@
+import {
+    chaiSetup,
+    constants,
+    expectTransactionFailedAsync,
+    expectTransactionFailedWithoutReasonAsync,
+    provider,
+    txDefaults,
+    web3Wrapper,
+} from '@0x/contracts-test-utils';
+import { BlockchainLifecycle } from '@0x/dev-utils';
+import { assetDataUtils } from '@0x/order-utils';
+import { AssetProxyId, RevertReason } from '@0x/types';
+import { AbiEncoder, BigNumber } from '@0x/utils';
+import * as chai from 'chai';
+import * as ethUtil from 'ethereumjs-util';
+
+import { artifacts, IAssetProxyContract, StaticCallProxyContract, TestStaticCallTargetContract } from '../src';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+describe('StaticCallProxy', () => {
+    const amount = constants.ZERO_AMOUNT;
+    let fromAddress: string;
+    let toAddress: string;
+
+    let staticCallProxy: IAssetProxyContract;
+    let staticCallTarget: TestStaticCallTargetContract;
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    before(async () => {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        [fromAddress, toAddress] = accounts.slice(0, 2);
+        const staticCallProxyWithoutTransferFrom = await StaticCallProxyContract.deployFrom0xArtifactAsync(
+            artifacts.StaticCallProxy,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+        staticCallProxy = new IAssetProxyContract(staticCallProxyWithoutTransferFrom.address, provider, txDefaults);
+        staticCallTarget = await TestStaticCallTargetContract.deployFrom0xArtifactAsync(
+            artifacts.TestStaticCallTarget,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    describe('general', () => {
+        it('should revert if undefined function is called', async () => {
+            const undefinedSelector = '0x01020304';
+            await expectTransactionFailedWithoutReasonAsync(
+                web3Wrapper.sendTransactionAsync({
+                    from: fromAddress,
+                    to: staticCallProxy.address,
+                    value: constants.ZERO_AMOUNT,
+                    data: undefinedSelector,
+                }),
+            );
+        });
+        it('should have an id of 0xc339d10a', async () => {
+            const proxyId = await staticCallProxy.getProxyId.callAsync();
+            const expectedProxyId = AssetProxyId.StaticCall;
+            expect(proxyId).to.equal(expectedProxyId);
+        });
+    });
+    describe('transferFrom', () => {
+        it('should revert if assetData lies outside the bounds of calldata', async () => {
+            const staticCallData = staticCallTarget.noInputFunction.getABIEncodedTransactionData();
+            const expectedResultHash = constants.KECCAK256_NULL;
+            const assetData = assetDataUtils.encodeStaticCallAssetData(
+                staticCallTarget.address,
+                staticCallData,
+                expectedResultHash,
+            );
+            const txData = staticCallProxy.transferFrom.getABIEncodedTransactionData(
+                assetData,
+                fromAddress,
+                toAddress,
+                amount,
+            );
+            const offsetToAssetData = '0000000000000000000000000000000000000000000000000000000000000080';
+            const txDataEndBuffer = ethUtil.toBuffer((txData.length - 2) / 2 - 4);
+            const paddedTxDataEndBuffer = ethUtil.setLengthLeft(txDataEndBuffer, 32);
+            const invalidOffsetToAssetData = ethUtil.bufferToHex(paddedTxDataEndBuffer).slice(2);
+            const newAssetData = '0000000000000000000000000000000000000000000000000000000000000304';
+            const badTxData = `${txData.replace(offsetToAssetData, invalidOffsetToAssetData)}${newAssetData}`;
+            await expectTransactionFailedWithoutReasonAsync(
+                web3Wrapper.sendTransactionAsync({
+                    to: staticCallProxy.address,
+                    from: fromAddress,
+                    data: badTxData,
+                }),
+            );
+        });
+        it('should revert if the length of assetData is less than 100 bytes', async () => {
+            const staticCallData = constants.NULL_BYTES;
+            const expectedResultHash = constants.KECCAK256_NULL;
+            const assetData = assetDataUtils
+                .encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
+                .slice(0, -128);
+            const assetDataByteLen = (assetData.length - 2) / 2;
+            expect((assetDataByteLen - 4) % 32).to.equal(0);
+            await expectTransactionFailedWithoutReasonAsync(
+                staticCallProxy.transferFrom.sendTransactionAsync(assetData, fromAddress, toAddress, amount),
+            );
+        });
+        it('should revert if the offset to `staticCallData` points to outside of assetData', async () => {
+            const staticCallData = staticCallTarget.noInputFunction.getABIEncodedTransactionData();
+            const expectedResultHash = constants.KECCAK256_NULL;
+            const assetData = assetDataUtils.encodeStaticCallAssetData(
+                staticCallTarget.address,
+                staticCallData,
+                expectedResultHash,
+            );
+            const offsetToStaticCallData = '0000000000000000000000000000000000000000000000000000000000000060';
+            const assetDataEndBuffer = ethUtil.toBuffer((assetData.length - 2) / 2 - 4);
+            const paddedAssetDataEndBuffer = ethUtil.setLengthLeft(assetDataEndBuffer, 32);
+            const invalidOffsetToStaticCallData = ethUtil.bufferToHex(paddedAssetDataEndBuffer).slice(2);
+            const newStaticCallData = '0000000000000000000000000000000000000000000000000000000000000304';
+            const badAssetData = `${assetData.replace(
+                offsetToStaticCallData,
+                invalidOffsetToStaticCallData,
+            )}${newStaticCallData}`;
+            await expectTransactionFailedWithoutReasonAsync(
+                staticCallProxy.transferFrom.sendTransactionAsync(badAssetData, fromAddress, toAddress, amount),
+            );
+        });
+        it('should revert if the callTarget attempts to write to state', async () => {
+            const staticCallData = staticCallTarget.updateState.getABIEncodedTransactionData();
+            const expectedResultHash = constants.KECCAK256_NULL;
+            const assetData = assetDataUtils.encodeStaticCallAssetData(
+                staticCallTarget.address,
+                staticCallData,
+                expectedResultHash,
+            );
+            await expectTransactionFailedWithoutReasonAsync(
+                staticCallProxy.transferFrom.sendTransactionAsync(assetData, fromAddress, toAddress, amount),
+            );
+        });
+        it('should revert with data provided by the callTarget if the staticcall reverts', async () => {
+            const staticCallData = staticCallTarget.assertEvenNumber.getABIEncodedTransactionData(new BigNumber(1));
+            const expectedResultHash = constants.KECCAK256_NULL;
+            const assetData = assetDataUtils.encodeStaticCallAssetData(
+                staticCallTarget.address,
+                staticCallData,
+                expectedResultHash,
+            );
+            await expectTransactionFailedAsync(
+                staticCallProxy.transferFrom.sendTransactionAsync(assetData, fromAddress, toAddress, amount),
+                RevertReason.TargetNotEven,
+            );
+        });
+        it('should revert if the hash of the output is different than expected expected', async () => {
+            const staticCallData = staticCallTarget.isOddNumber.getABIEncodedTransactionData(new BigNumber(0));
+            const trueAsBuffer = ethUtil.toBuffer('0x0000000000000000000000000000000000000000000000000000000000000001');
+            const expectedResultHash = ethUtil.bufferToHex(ethUtil.sha3(trueAsBuffer));
+            const assetData = assetDataUtils.encodeStaticCallAssetData(
+                staticCallTarget.address,
+                staticCallData,
+                expectedResultHash,
+            );
+            await expectTransactionFailedAsync(
+                staticCallProxy.transferFrom.sendTransactionAsync(assetData, fromAddress, toAddress, amount),
+                RevertReason.UnexpectedStaticCallResult,
+            );
+        });
+        it('should be successful if a function call with no inputs and no outputs is successful', async () => {
+            const staticCallData = staticCallTarget.noInputFunction.getABIEncodedTransactionData();
+            const expectedResultHash = constants.KECCAK256_NULL;
+            const assetData = assetDataUtils.encodeStaticCallAssetData(
+                staticCallTarget.address,
+                staticCallData,
+                expectedResultHash,
+            );
+            await staticCallProxy.transferFrom.awaitTransactionSuccessAsync(assetData, fromAddress, toAddress, amount);
+        });
+        it('should be successful if the staticCallTarget is not a contract and no return value is expected', async () => {
+            const staticCallData = '0x0102030405060708';
+            const expectedResultHash = constants.KECCAK256_NULL;
+            const assetData = assetDataUtils.encodeStaticCallAssetData(toAddress, staticCallData, expectedResultHash);
+            await staticCallProxy.transferFrom.awaitTransactionSuccessAsync(assetData, fromAddress, toAddress, amount);
+        });
+        it('should be successful if a function call with one static input returns the correct value', async () => {
+            const staticCallData = staticCallTarget.isOddNumber.getABIEncodedTransactionData(new BigNumber(1));
+            const trueAsBuffer = ethUtil.toBuffer('0x0000000000000000000000000000000000000000000000000000000000000001');
+            const expectedResultHash = ethUtil.bufferToHex(ethUtil.sha3(trueAsBuffer));
+            const assetData = assetDataUtils.encodeStaticCallAssetData(
+                staticCallTarget.address,
+                staticCallData,
+                expectedResultHash,
+            );
+            await staticCallProxy.transferFrom.awaitTransactionSuccessAsync(assetData, fromAddress, toAddress, amount);
+        });
+        it('should be successful if a function with one dynamic input is successful', async () => {
+            const dynamicInput = '0x0102030405060708';
+            const staticCallData = staticCallTarget.dynamicInputFunction.getABIEncodedTransactionData(dynamicInput);
+            const expectedResultHash = constants.KECCAK256_NULL;
+            const assetData = assetDataUtils.encodeStaticCallAssetData(
+                staticCallTarget.address,
+                staticCallData,
+                expectedResultHash,
+            );
+            await staticCallProxy.transferFrom.awaitTransactionSuccessAsync(assetData, fromAddress, toAddress, amount);
+        });
+        it('should be successful if a function call returns a complex type', async () => {
+            const a = new BigNumber(1);
+            const b = new BigNumber(2);
+            const staticCallData = staticCallTarget.returnComplexType.getABIEncodedTransactionData(a, b);
+            const abiEncoder = new AbiEncoder.DynamicBytes({
+                name: '',
+                type: 'bytes',
+            });
+            const aHex = '0000000000000000000000000000000000000000000000000000000000000001';
+            const bHex = '0000000000000000000000000000000000000000000000000000000000000002';
+            const expectedResults = `${staticCallTarget.address}${aHex}${bHex}`;
+            const offset = '0000000000000000000000000000000000000000000000000000000000000020';
+            const encodedExpectedResultWithOffset = `0x${offset}${abiEncoder.encode(expectedResults).slice(2)}`;
+            const expectedResultHash = ethUtil.bufferToHex(
+                ethUtil.sha3(ethUtil.toBuffer(encodedExpectedResultWithOffset)),
+            );
+            const assetData = assetDataUtils.encodeStaticCallAssetData(
+                staticCallTarget.address,
+                staticCallData,
+                expectedResultHash,
+            );
+            await staticCallProxy.transferFrom.awaitTransactionSuccessAsync(assetData, fromAddress, toAddress, amount);
+        });
+    });
+});

contracts/asset-proxy/test/utils/erc1155_proxy_wrapper.ts

@@ -0,0 +1,403 @@
+import { artifacts as erc1155Artifacts, ERC1155MintableContract, Erc1155Wrapper } from '@0x/contracts-erc1155';
+import {
+    constants,
+    ERC1155FungibleHoldingsByOwner,
+    ERC1155HoldingsByOwner,
+    ERC1155NonFungibleHoldingsByOwner,
+    LogDecoder,
+    txDefaults,
+} from '@0x/contracts-test-utils';
+import { assetDataUtils } from '@0x/order-utils';
+import { BigNumber } from '@0x/utils';
+import { Web3Wrapper } from '@0x/web3-wrapper';
+import { Provider, TransactionReceiptWithDecodedLogs } from 'ethereum-types';
+import * as _ from 'lodash';
+
+import { artifacts, ERC1155ProxyContract, IAssetProxyContract } from '../../src';
+
+export class ERC1155ProxyWrapper {
+    private readonly _tokenOwnerAddresses: string[];
+    private readonly _fungibleTokenIds: string[];
+    private readonly _nonFungibleTokenIds: string[];
+    private readonly _nfts: Array<{ id: BigNumber; tokenId: BigNumber }>;
+    private readonly _contractOwnerAddress: string;
+    private readonly _web3Wrapper: Web3Wrapper;
+    private readonly _provider: Provider;
+    private readonly _logDecoder: LogDecoder;
+    private readonly _dummyTokenWrappers: Erc1155Wrapper[];
+    private readonly _assetProxyInterface: IAssetProxyContract;
+    private _proxyContract?: ERC1155ProxyContract;
+    private _proxyIdIfExists?: string;
+    private _initialTokenIdsByOwner: ERC1155HoldingsByOwner = { fungible: {}, nonFungible: {} };
+
+    constructor(provider: Provider, tokenOwnerAddresses: string[], contractOwnerAddress: string) {
+        this._web3Wrapper = new Web3Wrapper(provider);
+        this._provider = provider;
+        const allArtifacts = _.merge(artifacts, erc1155Artifacts);
+        this._logDecoder = new LogDecoder(this._web3Wrapper, allArtifacts);
+        this._dummyTokenWrappers = [];
+        this._assetProxyInterface = new IAssetProxyContract(constants.NULL_ADDRESS, provider);
+        this._tokenOwnerAddresses = tokenOwnerAddresses;
+        this._contractOwnerAddress = contractOwnerAddress;
+        this._fungibleTokenIds = [];
+        this._nonFungibleTokenIds = [];
+        this._nfts = [];
+    }
+    /**
+     * @dev Deploys dummy ERC1155 contracts
+     * @return An array of ERC1155 wrappers; one for each deployed contract.
+     */
+    public async deployDummyContractsAsync(): Promise<Erc1155Wrapper[]> {
+        // tslint:disable-next-line:no-unused-variable
+        for (const i of _.times(constants.NUM_DUMMY_ERC1155_CONTRACTS_TO_DEPLOY)) {
+            const erc1155Contract = await ERC1155MintableContract.deployFrom0xArtifactAsync(
+                erc1155Artifacts.ERC1155Mintable,
+                this._provider,
+                txDefaults,
+                artifacts,
+            );
+            const erc1155Wrapper = new Erc1155Wrapper(erc1155Contract, this._provider, this._contractOwnerAddress);
+            this._dummyTokenWrappers.push(erc1155Wrapper);
+        }
+        return this._dummyTokenWrappers;
+    }
+    /**
+     * @dev Deploys the ERC1155 proxy
+     * @return Deployed ERC1155 proxy contract instance
+     */
+    public async deployProxyAsync(): Promise<ERC1155ProxyContract> {
+        this._proxyContract = await ERC1155ProxyContract.deployFrom0xArtifactAsync(
+            artifacts.ERC1155Proxy,
+            this._provider,
+            txDefaults,
+            artifacts,
+        );
+        this._proxyIdIfExists = await this._proxyContract.getProxyId.callAsync();
+        return this._proxyContract;
+    }
+    /**
+     * @dev Gets the ERC1155 proxy id
+     */
+    public getProxyId(): string {
+        this._validateProxyContractExistsOrThrow();
+        return this._proxyIdIfExists as string;
+    }
+    /**
+     * @dev generates abi-encoded tx data for transferring erc1155 fungible/non-fungible tokens.
+     * @param from source address
+     * @param to destination address
+     * @param contractAddress address of erc155 contract
+     * @param tokensToTransfer array of erc1155 tokens to transfer
+     * @param valuesToTransfer array of corresponding values for each erc1155 token to transfer
+     * @param valueMultiplier each value in `valuesToTransfer` is multiplied by this
+     * @param receiverCallbackData callback data if `to` is a contract
+     * @param authorizedSender sender of `transferFrom` transaction
+     * @param extraData extra data to append to `transferFrom` transaction. Optional.
+     * @return abi encoded tx data.
+     */
+    public getTransferFromAbiEncodedTxData(
+        from: string,
+        to: string,
+        contractAddress: string,
+        tokensToTransfer: BigNumber[],
+        valuesToTransfer: BigNumber[],
+        valueMultiplier: BigNumber,
+        receiverCallbackData: string,
+        authorizedSender: string,
+        assetData_?: string,
+    ): string {
+        this._validateProxyContractExistsOrThrow();
+        const assetData =
+            assetData_ === undefined
+                ? assetDataUtils.encodeERC1155AssetData(
+                      contractAddress,
+                      tokensToTransfer,
+                      valuesToTransfer,
+                      receiverCallbackData,
+                  )
+                : assetData_;
+        const data = this._assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+            assetData,
+            from,
+            to,
+            valueMultiplier,
+        );
+        return data;
+    }
+    /**
+     * @dev transfers erc1155 fungible/non-fungible tokens.
+     * @param txData: abi-encoded tx data
+     * @param authorizedSender sender of `transferFrom` transaction
+     */
+    public async transferFromRawAsync(
+        txData: string,
+        authorizedSender: string,
+    ): Promise<TransactionReceiptWithDecodedLogs> {
+        const txHash = await this._web3Wrapper.sendTransactionAsync({
+            to: (this._proxyContract as ERC1155ProxyContract).address,
+            data: txData,
+            from: authorizedSender,
+            gas: 300000,
+        });
+        const txReceipt = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
+        return txReceipt;
+    }
+    /**
+     * @dev transfers erc1155 fungible/non-fungible tokens.
+     * @param from source address
+     * @param to destination address
+     * @param contractAddress address of erc155 contract
+     * @param tokensToTransfer array of erc1155 tokens to transfer
+     * @param valuesToTransfer array of corresponding values for each erc1155 token to transfer
+     * @param valueMultiplier each value in `valuesToTransfer` is multiplied by this
+     * @param receiverCallbackData callback data if `to` is a contract
+     * @param authorizedSender sender of `transferFrom` transaction
+     * @param extraData extra data to append to `transferFrom` transaction. Optional.
+     * @return tranasction hash.
+     */
+    public async transferFromAsync(
+        from: string,
+        to: string,
+        contractAddress: string,
+        tokensToTransfer: BigNumber[],
+        valuesToTransfer: BigNumber[],
+        valueMultiplier: BigNumber,
+        receiverCallbackData: string,
+        authorizedSender: string,
+        assetData_?: string,
+    ): Promise<TransactionReceiptWithDecodedLogs> {
+        this._validateProxyContractExistsOrThrow();
+        const assetData =
+            assetData_ === undefined
+                ? assetDataUtils.encodeERC1155AssetData(
+                      contractAddress,
+                      tokensToTransfer,
+                      valuesToTransfer,
+                      receiverCallbackData,
+                  )
+                : assetData_;
+        const data = this._assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+            assetData,
+            from,
+            to,
+            valueMultiplier,
+        );
+        const txHash = await this._web3Wrapper.sendTransactionAsync({
+            to: (this._proxyContract as ERC1155ProxyContract).address,
+            data,
+            from: authorizedSender,
+            gas: 300000,
+        });
+        const txReceipt = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
+        return txReceipt;
+    }
+    /**
+     * @dev For each deployed ERC1155 contract, this function mints a set of fungible/non-fungible
+     *      tokens for each token owner address (`_tokenOwnerAddresses`).
+     * @return Balances of each token owner, across all ERC1155 contracts and tokens.
+     */
+    public async setBalancesAndAllowancesAsync(): Promise<ERC1155HoldingsByOwner> {
+        this._validateDummyTokenContractsExistOrThrow();
+        this._validateProxyContractExistsOrThrow();
+        this._initialTokenIdsByOwner = {
+            fungible: {},
+            nonFungible: {},
+        };
+        const fungibleHoldingsByOwner: ERC1155FungibleHoldingsByOwner = {};
+        const nonFungibleHoldingsByOwner: ERC1155NonFungibleHoldingsByOwner = {};
+        // Set balances accordingly
+        for (const dummyWrapper of this._dummyTokenWrappers) {
+            const dummyAddress = dummyWrapper.getContract().address;
+            // tslint:disable-next-line:no-unused-variable
+            for (const i of _.times(constants.NUM_ERC1155_FUNGIBLE_TOKENS_MINT)) {
+                // Create a fungible token
+                const tokenId = await dummyWrapper.mintFungibleTokensAsync(
+                    this._tokenOwnerAddresses,
+                    constants.INITIAL_ERC1155_FUNGIBLE_BALANCE,
+                );
+                const tokenIdAsString = tokenId.toString();
+                this._fungibleTokenIds.push(tokenIdAsString);
+                // Mint tokens for each owner for this token
+                for (const tokenOwnerAddress of this._tokenOwnerAddresses) {
+                    // tslint:disable-next-line:no-unused-variable
+                    if (fungibleHoldingsByOwner[tokenOwnerAddress] === undefined) {
+                        fungibleHoldingsByOwner[tokenOwnerAddress] = {};
+                    }
+                    if (fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress] === undefined) {
+                        fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress] = {};
+                    }
+                    fungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString] =
+                        constants.INITIAL_ERC1155_FUNGIBLE_BALANCE;
+                    await dummyWrapper.setApprovalForAllAsync(
+                        tokenOwnerAddress,
+                        (this._proxyContract as ERC1155ProxyContract).address,
+                        true,
+                    );
+                }
+            }
+            // Non-fungible tokens
+            // tslint:disable-next-line:no-unused-variable
+            for (const j of _.times(constants.NUM_ERC1155_NONFUNGIBLE_TOKENS_MINT)) {
+                const [tokenId, nftIds] = await dummyWrapper.mintNonFungibleTokensAsync(this._tokenOwnerAddresses);
+                const tokenIdAsString = tokenId.toString();
+                this._nonFungibleTokenIds.push(tokenIdAsString);
+                _.each(this._tokenOwnerAddresses, async (tokenOwnerAddress: string, i: number) => {
+                    if (nonFungibleHoldingsByOwner[tokenOwnerAddress] === undefined) {
+                        nonFungibleHoldingsByOwner[tokenOwnerAddress] = {};
+                    }
+                    if (nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress] === undefined) {
+                        nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress] = {};
+                    }
+                    if (nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString] === undefined) {
+                        nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString] = [];
+                    }
+                    this._nfts.push({ id: nftIds[i], tokenId });
+                    nonFungibleHoldingsByOwner[tokenOwnerAddress][dummyAddress][tokenIdAsString].push(nftIds[i]);
+                    await dummyWrapper.setApprovalForAllAsync(
+                        tokenOwnerAddress,
+                        (this._proxyContract as ERC1155ProxyContract).address,
+                        true,
+                    );
+                });
+            }
+        }
+        this._initialTokenIdsByOwner = {
+            fungible: fungibleHoldingsByOwner,
+            nonFungible: nonFungibleHoldingsByOwner,
+        };
+        return this._initialTokenIdsByOwner;
+    }
+    /**
+     * @dev For each deployed ERC1155 contract, this function quieries the set of fungible/non-fungible
+     *      tokens for each token owner address (`_tokenOwnerAddresses`).
+     * @return Balances of each token owner, across all ERC1155 contracts and tokens.
+     */
+    public async getBalancesAsync(): Promise<ERC1155HoldingsByOwner> {
+        this._validateDummyTokenContractsExistOrThrow();
+        this._validateBalancesAndAllowancesSetOrThrow();
+        const tokenHoldingsByOwner: ERC1155FungibleHoldingsByOwner = {};
+        const nonFungibleHoldingsByOwner: ERC1155NonFungibleHoldingsByOwner = {};
+        for (const dummyTokenWrapper of this._dummyTokenWrappers) {
+            const tokenContract = dummyTokenWrapper.getContract();
+            const tokenAddress = tokenContract.address;
+            // Construct batch balance call
+            const tokenOwners: string[] = [];
+            const tokenIds: BigNumber[] = [];
+            for (const tokenOwnerAddress of this._tokenOwnerAddresses) {
+                for (const tokenId of this._fungibleTokenIds) {
+                    tokenOwners.push(tokenOwnerAddress);
+                    tokenIds.push(new BigNumber(tokenId));
+                }
+                for (const nft of this._nfts) {
+                    tokenOwners.push(tokenOwnerAddress);
+                    tokenIds.push(nft.id);
+                }
+            }
+            const balances = await dummyTokenWrapper.getBalancesAsync(tokenOwners, tokenIds);
+            // Parse out balances into fungible / non-fungible token holdings
+            let i = 0;
+            for (const tokenOwnerAddress of this._tokenOwnerAddresses) {
+                // Fungible tokens
+                for (const tokenId of this._fungibleTokenIds) {
+                    if (tokenHoldingsByOwner[tokenOwnerAddress] === undefined) {
+                        tokenHoldingsByOwner[tokenOwnerAddress] = {};
+                    }
+                    if (tokenHoldingsByOwner[tokenOwnerAddress][tokenAddress] === undefined) {
+                        tokenHoldingsByOwner[tokenOwnerAddress][tokenAddress] = {};
+                    }
+                    tokenHoldingsByOwner[tokenOwnerAddress][tokenAddress][tokenId] = balances[i++];
+                }
+                // Non-fungible tokens
+                for (const nft of this._nfts) {
+                    if (nonFungibleHoldingsByOwner[tokenOwnerAddress] === undefined) {
+                        nonFungibleHoldingsByOwner[tokenOwnerAddress] = {};
+                    }
+                    if (nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress] === undefined) {
+                        nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress] = {};
+                    }
+                    if (
+                        nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress][nft.tokenId.toString()] ===
+                        undefined
+                    ) {
+                        nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress][nft.tokenId.toString()] = [];
+                    }
+                    const isOwner = balances[i++];
+                    if (isOwner.isEqualTo(1)) {
+                        nonFungibleHoldingsByOwner[tokenOwnerAddress][tokenAddress][nft.tokenId.toString()].push(
+                            nft.id,
+                        );
+                    }
+                }
+            }
+        }
+        const holdingsByOwner = {
+            fungible: tokenHoldingsByOwner,
+            nonFungible: nonFungibleHoldingsByOwner,
+        };
+        return holdingsByOwner;
+    }
+    /**
+     * @dev Checks if proxy is approved to transfer tokens on behalf of `userAddress`.
+     * @param userAddress owner of ERC1155 tokens.
+     * @param contractAddress address of ERC1155 contract.
+     * @return True iff the proxy is approved for all. False otherwise.
+     */
+    public async isProxyApprovedForAllAsync(userAddress: string, contractAddress: string): Promise<boolean> {
+        this._validateProxyContractExistsOrThrow();
+        const tokenContract = this._getContractFromAddress(contractAddress);
+        const operator = (this._proxyContract as ERC1155ProxyContract).address;
+        const didApproveAll = await tokenContract.isApprovedForAll.callAsync(userAddress, operator);
+        return didApproveAll;
+    }
+    public getFungibleTokenIds(): BigNumber[] {
+        const fungibleTokenIds = _.map(this._fungibleTokenIds, (tokenIdAsString: string) => {
+            return new BigNumber(tokenIdAsString);
+        });
+        return fungibleTokenIds;
+    }
+    public getNonFungibleTokenIds(): BigNumber[] {
+        const nonFungibleTokenIds = _.map(this._nonFungibleTokenIds, (tokenIdAsString: string) => {
+            return new BigNumber(tokenIdAsString);
+        });
+        return nonFungibleTokenIds;
+    }
+    public getTokenOwnerAddresses(): string[] {
+        return this._tokenOwnerAddresses;
+    }
+    public getContractWrapper(contractAddress: string): Erc1155Wrapper {
+        const tokenWrapper = _.find(this._dummyTokenWrappers, (wrapper: Erc1155Wrapper) => {
+            return wrapper.getContract().address === contractAddress;
+        });
+        if (tokenWrapper === undefined) {
+            throw new Error(`Contract: ${contractAddress} was not deployed through ERC1155ProxyWrapper`);
+        }
+        return tokenWrapper;
+    }
+    private _getContractFromAddress(tokenAddress: string): ERC1155MintableContract {
+        const tokenContractIfExists = _.find(this._dummyTokenWrappers, c => c.getContract().address === tokenAddress);
+        if (tokenContractIfExists === undefined) {
+            throw new Error(`Token: ${tokenAddress} was not deployed through ERC1155ProxyWrapper`);
+        }
+        return tokenContractIfExists.getContract();
+    }
+    private _validateDummyTokenContractsExistOrThrow(): void {
+        if (this._dummyTokenWrappers === undefined) {
+            throw new Error('Dummy ERC1155 tokens not yet deployed, please call "deployDummyTokensAsync"');
+        }
+    }
+    private _validateProxyContractExistsOrThrow(): void {
+        if (this._proxyContract === undefined) {
+            throw new Error('ERC1155 proxy contract not yet deployed, please call "deployProxyAsync"');
+        }
+    }
+    private _validateBalancesAndAllowancesSetOrThrow(): void {
+        if (
+            _.keys(this._initialTokenIdsByOwner.fungible).length === 0 ||
+            _.keys(this._initialTokenIdsByOwner.nonFungible).length === 0
+        ) {
+            throw new Error(
+                'Dummy ERC1155 balances and allowances not yet set, please call "setBalancesAndAllowancesAsync"',
+            );
+        }
+    }
+}

contracts/asset-proxy/test/utils/erc20_wrapper.ts

@@ -1,17 +1,16 @@
+import { artifacts as erc20Artifacts, DummyERC20TokenContract } from '@0x/contracts-erc20';
 import { constants, ERC20BalancesByOwner, txDefaults } from '@0x/contracts-test-utils';
 import { assetDataUtils } from '@0x/order-utils';
 import { BigNumber } from '@0x/utils';
-import { Web3Wrapper } from '@0x/web3-wrapper';
-import { Provider } from 'ethereum-types';
+import { ZeroExProvider } from 'ethereum-types';
 import * as _ from 'lodash';
 
-import { artifacts, DummyERC20TokenContract, ERC20ProxyContract } from '../../src';
+import { artifacts, ERC20ProxyContract } from '../../src';
 
 export class ERC20Wrapper {
     private readonly _tokenOwnerAddresses: string[];
     private readonly _contractOwnerAddress: string;
-    private readonly _web3Wrapper: Web3Wrapper;
-    private readonly _provider: Provider;
+    private readonly _provider: ZeroExProvider;
     private readonly _dummyTokenContracts: DummyERC20TokenContract[];
     private _proxyContract?: ERC20ProxyContract;
     private _proxyIdIfExists?: string;
@@ -22,9 +21,8 @@ export class ERC20Wrapper {
      * @param contractOwnerAddress Desired owner of the contract
      * Instance of ERC20Wrapper
      */
-    constructor(provider: Provider, tokenOwnerAddresses: string[], contractOwnerAddress: string) {
+    constructor(provider: ZeroExProvider, tokenOwnerAddresses: string[], contractOwnerAddress: string) {
         this._dummyTokenContracts = [];
-        this._web3Wrapper = new Web3Wrapper(provider);
         this._provider = provider;
         this._tokenOwnerAddresses = tokenOwnerAddresses;
         this._contractOwnerAddress = contractOwnerAddress;
@@ -36,9 +34,10 @@ export class ERC20Wrapper {
         for (let i = 0; i < numberToDeploy; i++) {
             this._dummyTokenContracts.push(
                 await DummyERC20TokenContract.deployFrom0xArtifactAsync(
-                    artifacts.DummyERC20Token,
+                    erc20Artifacts.DummyERC20Token,
                     this._provider,
                     txDefaults,
+                    artifacts,
                     constants.DUMMY_TOKEN_NAME,
                     constants.DUMMY_TOKEN_SYMBOL,
                     decimals,
@@ -53,6 +52,7 @@ export class ERC20Wrapper {
             artifacts.ERC20Proxy,
             this._provider,
             txDefaults,
+            artifacts,
         );
         this._proxyIdIfExists = await this._proxyContract.getProxyId.callAsync();
         return this._proxyContract;
@@ -66,20 +66,16 @@ export class ERC20Wrapper {
         this._validateProxyContractExistsOrThrow();
         for (const dummyTokenContract of this._dummyTokenContracts) {
             for (const tokenOwnerAddress of this._tokenOwnerAddresses) {
-                await this._web3Wrapper.awaitTransactionSuccessAsync(
-                    await dummyTokenContract.setBalance.sendTransactionAsync(
-                        tokenOwnerAddress,
-                        constants.INITIAL_ERC20_BALANCE,
-                        { from: this._contractOwnerAddress },
-                    ),
+                await dummyTokenContract.setBalance.awaitTransactionSuccessAsync(
+                    tokenOwnerAddress,
+                    constants.INITIAL_ERC20_BALANCE,
+                    { from: this._contractOwnerAddress },
                     constants.AWAIT_TRANSACTION_MINED_MS,
                 );
-                await this._web3Wrapper.awaitTransactionSuccessAsync(
-                    await dummyTokenContract.approve.sendTransactionAsync(
-                        (this._proxyContract as ERC20ProxyContract).address,
-                        constants.INITIAL_ERC20_ALLOWANCE,
-                        { from: tokenOwnerAddress },
-                    ),
+                await dummyTokenContract.approve.awaitTransactionSuccessAsync(
+                    (this._proxyContract as ERC20ProxyContract).address,
+                    constants.INITIAL_ERC20_ALLOWANCE,
+                    { from: tokenOwnerAddress },
                     constants.AWAIT_TRANSACTION_MINED_MS,
                 );
             }
@@ -92,10 +88,10 @@ export class ERC20Wrapper {
     }
     public async setBalanceAsync(userAddress: string, assetData: string, amount: BigNumber): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(assetData);
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.setBalance.sendTransactionAsync(userAddress, amount, {
-                from: this._contractOwnerAddress,
-            }),
+        await tokenContract.setBalance.awaitTransactionSuccessAsync(
+            userAddress,
+            amount,
+            { from: this._contractOwnerAddress },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
     }
@@ -108,10 +104,10 @@ export class ERC20Wrapper {
     public async setAllowanceAsync(userAddress: string, assetData: string, amount: BigNumber): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(assetData);
         const proxyAddress = (this._proxyContract as ERC20ProxyContract).address;
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.approve.sendTransactionAsync(proxyAddress, amount, {
-                from: userAddress,
-            }),
+        await tokenContract.approve.awaitTransactionSuccessAsync(
+            proxyAddress,
+            amount,
+            { from: userAddress },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
     }
@@ -132,7 +128,7 @@ export class ERC20Wrapper {
         _.forEach(balances, (balance, balanceIndex) => {
             const tokenAddress = balanceInfo[balanceIndex].tokenAddress;
             const tokenOwnerAddress = balanceInfo[balanceIndex].tokenOwnerAddress;
-            if (_.isUndefined(balancesByOwner[tokenOwnerAddress])) {
+            if (balancesByOwner[tokenOwnerAddress] === undefined) {
                 balancesByOwner[tokenOwnerAddress] = {};
             }
             const wrappedBalance = new BigNumber(balance);
@@ -141,7 +137,7 @@ export class ERC20Wrapper {
         return balancesByOwner;
     }
     public addDummyTokenContract(dummy: DummyERC20TokenContract): void {
-        if (!_.isUndefined(this._dummyTokenContracts)) {
+        if (this._dummyTokenContracts !== undefined) {
             this._dummyTokenContracts.push(dummy);
         }
     }
@@ -159,18 +155,18 @@ export class ERC20Wrapper {
         const erc20ProxyData = assetDataUtils.decodeERC20AssetData(assetData);
         const tokenAddress = erc20ProxyData.tokenAddress;
         const tokenContractIfExists = _.find(this._dummyTokenContracts, c => c.address === tokenAddress);
-        if (_.isUndefined(tokenContractIfExists)) {
+        if (tokenContractIfExists === undefined) {
             throw new Error(`Token: ${tokenAddress} was not deployed through ERC20Wrapper`);
         }
         return tokenContractIfExists;
     }
     private _validateDummyTokenContractsExistOrThrow(): void {
-        if (_.isUndefined(this._dummyTokenContracts)) {
+        if (this._dummyTokenContracts === undefined) {
             throw new Error('Dummy ERC20 tokens not yet deployed, please call "deployDummyTokensAsync"');
         }
     }
     private _validateProxyContractExistsOrThrow(): void {
-        if (_.isUndefined(this._proxyContract)) {
+        if (this._proxyContract === undefined) {
             throw new Error('ERC20 proxy contract not yet deployed, please call "deployProxyAsync"');
         }
     }

contracts/asset-proxy/test/utils/erc721_wrapper.ts

@@ -1,23 +1,21 @@
+import { artifacts as erc721Artifacts, DummyERC721TokenContract } from '@0x/contracts-erc721';
 import { constants, ERC721TokenIdsByOwner, txDefaults } from '@0x/contracts-test-utils';
 import { generatePseudoRandomSalt } from '@0x/order-utils';
 import { BigNumber } from '@0x/utils';
-import { Web3Wrapper } from '@0x/web3-wrapper';
-import { Provider } from 'ethereum-types';
+import { ZeroExProvider } from 'ethereum-types';
 import * as _ from 'lodash';
 
-import { artifacts, DummyERC721TokenContract, ERC721ProxyContract } from '../../src';
+import { artifacts, ERC721ProxyContract } from '../../src';
 
 export class ERC721Wrapper {
     private readonly _tokenOwnerAddresses: string[];
     private readonly _contractOwnerAddress: string;
-    private readonly _web3Wrapper: Web3Wrapper;
-    private readonly _provider: Provider;
+    private readonly _provider: ZeroExProvider;
     private readonly _dummyTokenContracts: DummyERC721TokenContract[];
     private _proxyContract?: ERC721ProxyContract;
     private _proxyIdIfExists?: string;
     private _initialTokenIdsByOwner: ERC721TokenIdsByOwner = {};
-    constructor(provider: Provider, tokenOwnerAddresses: string[], contractOwnerAddress: string) {
-        this._web3Wrapper = new Web3Wrapper(provider);
+    constructor(provider: ZeroExProvider, tokenOwnerAddresses: string[], contractOwnerAddress: string) {
         this._provider = provider;
         this._dummyTokenContracts = [];
         this._tokenOwnerAddresses = tokenOwnerAddresses;
@@ -28,9 +26,10 @@ export class ERC721Wrapper {
         for (const i of _.times(constants.NUM_DUMMY_ERC721_TO_DEPLOY)) {
             this._dummyTokenContracts.push(
                 await DummyERC721TokenContract.deployFrom0xArtifactAsync(
-                    artifacts.DummyERC721Token,
+                    erc721Artifacts.DummyERC721Token,
                     this._provider,
                     txDefaults,
+                    artifacts,
                     constants.DUMMY_TOKEN_NAME,
                     constants.DUMMY_TOKEN_SYMBOL,
                 ),
@@ -43,6 +42,7 @@ export class ERC721Wrapper {
             artifacts.ERC721Proxy,
             this._provider,
             txDefaults,
+            artifacts,
         );
         this._proxyIdIfExists = await this._proxyContract.getProxyId.callAsync();
         return this._proxyContract;
@@ -61,12 +61,12 @@ export class ERC721Wrapper {
                 for (const i of _.times(constants.NUM_ERC721_TOKENS_TO_MINT)) {
                     const tokenId = generatePseudoRandomSalt();
                     await this.mintAsync(dummyTokenContract.address, tokenId, tokenOwnerAddress);
-                    if (_.isUndefined(this._initialTokenIdsByOwner[tokenOwnerAddress])) {
+                    if (this._initialTokenIdsByOwner[tokenOwnerAddress] === undefined) {
                         this._initialTokenIdsByOwner[tokenOwnerAddress] = {
                             [dummyTokenContract.address]: [],
                         };
                     }
-                    if (_.isUndefined(this._initialTokenIdsByOwner[tokenOwnerAddress][dummyTokenContract.address])) {
+                    if (this._initialTokenIdsByOwner[tokenOwnerAddress][dummyTokenContract.address] === undefined) {
                         this._initialTokenIdsByOwner[tokenOwnerAddress][dummyTokenContract.address] = [];
                     }
                     this._initialTokenIdsByOwner[tokenOwnerAddress][dummyTokenContract.address].push(tokenId);
@@ -90,20 +90,20 @@ export class ERC721Wrapper {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
         const tokenOwner = await this.ownerOfAsync(tokenAddress, tokenId);
         const proxyAddress = (this._proxyContract as ERC721ProxyContract).address;
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.setApprovalForAll.sendTransactionAsync(proxyAddress, isApproved, {
-                from: tokenOwner,
-            }),
+        await tokenContract.setApprovalForAll.awaitTransactionSuccessAsync(
+            proxyAddress,
+            isApproved,
+            { from: tokenOwner },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
     }
     public async approveAsync(to: string, tokenAddress: string, tokenId: BigNumber): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
         const tokenOwner = await this.ownerOfAsync(tokenAddress, tokenId);
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.approve.sendTransactionAsync(to, tokenId, {
-                from: tokenOwner,
-            }),
+        await tokenContract.approve.awaitTransactionSuccessAsync(
+            to,
+            tokenId,
+            { from: tokenOwner },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
     }
@@ -114,28 +114,29 @@ export class ERC721Wrapper {
         userAddress: string,
     ): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.transferFrom.sendTransactionAsync(currentOwner, userAddress, tokenId, {
-                from: currentOwner,
-            }),
+        await tokenContract.transferFrom.awaitTransactionSuccessAsync(
+            currentOwner,
+            userAddress,
+            tokenId,
+            { from: currentOwner },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
     }
     public async mintAsync(tokenAddress: string, tokenId: BigNumber, userAddress: string): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.mint.sendTransactionAsync(userAddress, tokenId, {
-                from: this._contractOwnerAddress,
-            }),
+        await tokenContract.mint.awaitTransactionSuccessAsync(
+            userAddress,
+            tokenId,
+            { from: this._contractOwnerAddress },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
     }
     public async burnAsync(tokenAddress: string, tokenId: BigNumber, owner: string): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.burn.sendTransactionAsync(owner, tokenId, {
-                from: this._contractOwnerAddress,
-            }),
+        await tokenContract.burn.awaitTransactionSuccessAsync(
+            owner,
+            tokenId,
+            { from: this._contractOwnerAddress },
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
     }
@@ -188,12 +189,12 @@ export class ERC721Wrapper {
         _.forEach(tokenOwnerAddresses, (tokenOwnerAddress, ownerIndex) => {
             const tokenAddress = tokenInfo[ownerIndex].tokenAddress;
             const tokenId = tokenInfo[ownerIndex].tokenId;
-            if (_.isUndefined(tokenIdsByOwner[tokenOwnerAddress])) {
+            if (tokenIdsByOwner[tokenOwnerAddress] === undefined) {
                 tokenIdsByOwner[tokenOwnerAddress] = {
                     [tokenAddress]: [],
                 };
             }
-            if (_.isUndefined(tokenIdsByOwner[tokenOwnerAddress][tokenAddress])) {
+            if (tokenIdsByOwner[tokenOwnerAddress][tokenAddress] === undefined) {
                 tokenIdsByOwner[tokenOwnerAddress][tokenAddress] = [];
             }
             tokenIdsByOwner[tokenOwnerAddress][tokenAddress].push(tokenId);
@@ -209,18 +210,18 @@ export class ERC721Wrapper {
     }
     private _getTokenContractFromAssetData(tokenAddress: string): DummyERC721TokenContract {
         const tokenContractIfExists = _.find(this._dummyTokenContracts, c => c.address === tokenAddress);
-        if (_.isUndefined(tokenContractIfExists)) {
+        if (tokenContractIfExists === undefined) {
             throw new Error(`Token: ${tokenAddress} was not deployed through ERC20Wrapper`);
         }
         return tokenContractIfExists;
     }
     private _validateDummyTokenContractsExistOrThrow(): void {
-        if (_.isUndefined(this._dummyTokenContracts)) {
+        if (this._dummyTokenContracts === undefined) {
             throw new Error('Dummy ERC721 tokens not yet deployed, please call "deployDummyTokensAsync"');
         }
     }
     private _validateProxyContractExistsOrThrow(): void {
-        if (_.isUndefined(this._proxyContract)) {
+        if (this._proxyContract === undefined) {
             throw new Error('ERC721 proxy contract not yet deployed, please call "deployProxyAsync"');
         }
     }

contracts/asset-proxy/test/utils/index.ts

@@ -1,2 +1,3 @@
 export * from './erc20_wrapper';
 export * from './erc721_wrapper';
+export * from './erc1155_proxy_wrapper';

contracts/asset-proxy/tsconfig.json

@@ -3,18 +3,16 @@
     "compilerOptions": { "outDir": "lib", "rootDir": ".", "resolveJsonModule": true },
     "include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*"],
     "files": [
-        "generated-artifacts/DummyERC20Token.json",
-        "generated-artifacts/DummyERC721Receiver.json",
-        "generated-artifacts/DummyERC721Token.json",
-        "generated-artifacts/DummyMultipleReturnERC20Token.json",
-        "generated-artifacts/DummyNoReturnERC20Token.json",
+        "generated-artifacts/ERC1155Proxy.json",
         "generated-artifacts/ERC20Proxy.json",
         "generated-artifacts/ERC721Proxy.json",
         "generated-artifacts/IAssetData.json",
         "generated-artifacts/IAssetProxy.json",
         "generated-artifacts/IAuthorizable.json",
         "generated-artifacts/MixinAuthorizable.json",
-        "generated-artifacts/MultiAssetProxy.json"
+        "generated-artifacts/MultiAssetProxy.json",
+        "generated-artifacts/StaticCallProxy.json",
+        "generated-artifacts/TestStaticCallTarget.json"
     ],
     "exclude": ["./deploy/solc/solc_bin"]
 }

contracts/coordinator/CHANGELOG.json

@@ -0,0 +1,129 @@
+[
+    {
+        "version": "2.0.9",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564604963
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "2.0.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "2.0.7",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "2.0.6",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563006338,
+        "version": "2.0.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1558712885,
+        "version": "2.0.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1557961111,
+        "version": "2.0.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1557799313,
+        "version": "2.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1557507213,
+        "version": "2.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "2.0.0",
+        "changes": [
+            {
+                "note": "Make `decodeOrdersFromFillData`, `getCoordinatorApprovalHash`, and `getTransactionHash` public",
+                "pr": 1729
+            },
+            {
+                "note": "Make `assertValidTransactionOrdersApproval` internal",
+                "pr": 1729
+            }
+        ],
+        "timestamp": 1554997931
+    },
+    {
+        "version": "1.1.0",
+        "changes": [
+            {
+                "note": "Run Web3ProviderEngine without excess block polling",
+                "pr": 1695
+            }
+        ],
+        "timestamp": 1553183790
+    },
+    {
+        "version": "1.0.0",
+        "changes": [
+            {
+                "note": "Created Coordinator package"
+            },
+            {
+                "note": "Use separate EIP712 domains for transactions and approvals",
+                "pr": 1705
+            },
+            {
+                "note": "Add `SignatureType.Invalid`",
+                "pr": 1705
+            },
+            {
+                "note": "Set `evmVersion` to `constantinople`",
+                "pr": 1707
+            }
+        ],
+        "timestamp": 1553091633
+    }
+]

contracts/coordinator/CHANGELOG.md

@@ -0,0 +1,58 @@
+<!--
+changelogUtils.file is auto-generated using the monorepo-scripts package. Don't edit directly.
+Edit the package's CHANGELOG.json file only.
+-->
+
+CHANGELOG
+
+## v2.0.9 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v2.0.8 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v2.0.7 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v2.0.6 - _July 13, 2019_
+
+    * Dependencies updated
+
+## v2.0.5 - _July 13, 2019_
+
+    * Dependencies updated
+
+## v2.0.4 - _May 24, 2019_
+
+    * Dependencies updated
+
+## v2.0.3 - _May 15, 2019_
+
+    * Dependencies updated
+
+## v2.0.2 - _May 14, 2019_
+
+    * Dependencies updated
+
+## v2.0.1 - _May 10, 2019_
+
+    * Dependencies updated
+
+## v2.0.0 - _April 11, 2019_
+
+    * Make `decodeOrdersFromFillData`, `getCoordinatorApprovalHash`, and `getTransactionHash` public (#1729)
+    * Make `assertValidTransactionOrdersApproval` internal (#1729)
+
+## v1.1.0 - _March 21, 2019_
+
+    * Run Web3ProviderEngine without excess block polling (#1695)
+
+## v1.0.0 - _March 20, 2019_
+
+    * Created Coordinator package
+    * Use separate EIP712 domains for transactions and approvals (#1705)
+    * Add `SignatureType.Invalid` (#1705)
+    * Set `evmVersion` to `constantinople` (#1707)

contracts/coordinator/DEPLOYS.json

@@ -0,0 +1 @@
+[]

contracts/coordinator/README.md

@@ -0,0 +1,73 @@
+## Coordinator
+
+This package contains a contract that allows users to call arbitrary functions on the Exchange contract with permission from one or more Coordinators. Addresses of the deployed contracts can be found in the 0x [wiki](https://0xproject.com/wiki#Deployed-Addresses) or the [DEPLOYS](./DEPLOYS.json) file within this package.
+
+## Installation
+
+**Install**
+
+```bash
+npm install @0x/contracts-coordinator --save
+```
+
+## Bug bounty
+
+A bug bounty for the 2.0.0 contracts is ongoing! Instructions can be found [here](https://0xproject.com/wiki#Bug-Bounty).
+
+## Contributing
+
+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.
+
+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](../../CONTRIBUTING.md) before getting started.
+
+### Install Dependencies
+
+If you don't have yarn workspaces enabled (Yarn < v1.0) - enable them:
+
+```bash
+yarn config set workspaces-experimental true
+```
+
+Then install dependencies
+
+```bash
+yarn install
+```
+
+### Build
+
+To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
+
+```bash
+PKG=@0x/contracts-coordinator yarn build
+```
+
+Or continuously rebuild on change:
+
+```bash
+PKG=@0x/contracts-coordinator yarn watch
+```
+
+### Clean
+
+```bash
+yarn clean
+```
+
+### Lint
+
+```bash
+yarn lint
+```
+
+### Run Tests
+
+```bash
+yarn test
+```
+
+#### Testing options
+
+Contracts testing options like coverage, profiling, revert traces or backing node choosing - are described [here](../TESTING.md).

contracts/coordinator/compiler.json

@@ -0,0 +1,26 @@
+{
+    "artifactsDir": "./generated-artifacts",
+    "contractsDir": "./contracts",
+    "useDockerisedSolc": false,
+    "compilerSettings": {
+        "evmVersion": "constantinople",
+        "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"
+                ]
+            }
+        }
+    },
+    "contracts": ["src/Coordinator.sol", "src/registry/CoordinatorRegistry.sol"]
+}

contracts/coordinator/contracts/src/Coordinator.sol

@@ -0,0 +1,39 @@
+/*
+
+  Copyright 2018 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;
+pragma experimental "ABIEncoderV2";
+
+import "./libs/LibConstants.sol";
+import "./MixinSignatureValidator.sol";
+import "./MixinCoordinatorApprovalVerifier.sol";
+import "./MixinCoordinatorCore.sol";
+
+
+// solhint-disable no-empty-blocks
+contract Coordinator is
+    LibConstants,
+    MixinSignatureValidator,
+    MixinCoordinatorApprovalVerifier,
+    MixinCoordinatorCore
+{
+    constructor (address _exchange)
+        public
+        LibConstants(_exchange)
+    {}
+}

contracts/coordinator/contracts/src/MixinCoordinatorApprovalVerifier.sol

@@ -0,0 +1,203 @@
+/*
+
+  Copyright 2018 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;
+pragma experimental "ABIEncoderV2";
+
+import "@0x/contracts-exchange-libs/contracts/src/LibExchangeSelectors.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
+import "@0x/contracts-utils/contracts/src/LibBytes.sol";
+import "@0x/contracts-utils/contracts/src/LibAddressArray.sol";
+import "./libs/LibCoordinatorApproval.sol";
+import "./libs/LibZeroExTransaction.sol";
+import "./mixins/MSignatureValidator.sol";
+import "./mixins/MCoordinatorApprovalVerifier.sol";
+
+
+// solhint-disable avoid-tx-origin
+contract MixinCoordinatorApprovalVerifier is
+    LibExchangeSelectors,
+    LibCoordinatorApproval,
+    LibZeroExTransaction,
+    MSignatureValidator,
+    MCoordinatorApprovalVerifier
+{
+    using LibBytes for bytes;
+    using LibAddressArray for address[];
+
+    /// @dev Validates that the 0x transaction has been approved by all of the feeRecipients
+    ///      that correspond to each order in the transaction's Exchange calldata.
+    /// @param transaction 0x transaction containing salt, signerAddress, and data.
+    /// @param txOrigin Required signer of Ethereum transaction calling this function.
+    /// @param transactionSignature Proof that the transaction has been signed by the signer.
+    /// @param approvalExpirationTimeSeconds Array of expiration times in seconds for which each corresponding approval signature expires.
+    /// @param approvalSignatures Array of signatures that correspond to the feeRecipients of each order in the transaction's Exchange calldata.
+    function assertValidCoordinatorApprovals(
+        LibZeroExTransaction.ZeroExTransaction memory transaction,
+        address txOrigin,
+        bytes memory transactionSignature,
+        uint256[] memory approvalExpirationTimeSeconds,
+        bytes[] memory approvalSignatures
+    )
+        public
+        view
+    {
+        // Get the orders from the the Exchange calldata in the 0x transaction
+        LibOrder.Order[] memory orders = decodeOrdersFromFillData(transaction.data);
+
+        // No approval is required for non-fill methods
+        if (orders.length > 0) {
+            // Revert if approval is invalid for transaction orders
+            assertValidTransactionOrdersApproval(
+                transaction,
+                orders,
+                txOrigin,
+                transactionSignature,
+                approvalExpirationTimeSeconds,
+                approvalSignatures
+            );
+        }
+    }
+
+    /// @dev Decodes the orders from Exchange calldata representing any fill method.
+    /// @param data Exchange calldata representing a fill method.
+    /// @return The orders from the Exchange calldata.
+    function decodeOrdersFromFillData(bytes memory data)
+        public
+        pure
+        returns (LibOrder.Order[] memory orders)
+    {
+        bytes4 selector = data.readBytes4(0);
+        if (
+            selector == FILL_ORDER_SELECTOR ||
+            selector == FILL_ORDER_NO_THROW_SELECTOR ||
+            selector == FILL_OR_KILL_ORDER_SELECTOR
+        ) {
+            // Decode single order
+            (LibOrder.Order memory order) = abi.decode(
+                data.slice(4, data.length),
+                (LibOrder.Order)
+            );
+            orders = new LibOrder.Order[](1);
+            orders[0] = order;
+        } else if (
+            selector == BATCH_FILL_ORDERS_SELECTOR ||
+            selector == BATCH_FILL_ORDERS_NO_THROW_SELECTOR ||
+            selector == BATCH_FILL_OR_KILL_ORDERS_SELECTOR ||
+            selector == MARKET_BUY_ORDERS_SELECTOR ||
+            selector == MARKET_BUY_ORDERS_NO_THROW_SELECTOR ||
+            selector == MARKET_SELL_ORDERS_SELECTOR ||
+            selector == MARKET_SELL_ORDERS_NO_THROW_SELECTOR
+        ) {
+            // Decode all orders
+            // solhint-disable indent
+            (orders) = abi.decode(
+                data.slice(4, data.length),
+                (LibOrder.Order[])
+            );
+        } else if (selector == MATCH_ORDERS_SELECTOR) {
+            // Decode left and right orders
+            (LibOrder.Order memory leftOrder, LibOrder.Order memory rightOrder) = abi.decode(
+                data.slice(4, data.length),
+                (LibOrder.Order, LibOrder.Order)
+            );
+
+            // Create array of orders
+            orders = new LibOrder.Order[](2);
+            orders[0] = leftOrder;
+            orders[1] = rightOrder;
+        }
+        return orders;
+    }
+
+    /// @dev Validates that the feeRecipients of a batch of order have approved a 0x transaction.
+    /// @param transaction 0x transaction containing salt, signerAddress, and data.
+    /// @param orders Array of order structs containing order specifications.
+    /// @param txOrigin Required signer of Ethereum transaction calling this function.
+    /// @param transactionSignature Proof that the transaction has been signed by the signer.
+    /// @param approvalExpirationTimeSeconds Array of expiration times in seconds for which each corresponding approval signature expires.
+    /// @param approvalSignatures Array of signatures that correspond to the feeRecipients of each order.
+    function assertValidTransactionOrdersApproval(
+        LibZeroExTransaction.ZeroExTransaction memory transaction,
+        LibOrder.Order[] memory orders,
+        address txOrigin,
+        bytes memory transactionSignature,
+        uint256[] memory approvalExpirationTimeSeconds,
+        bytes[] memory approvalSignatures
+    )
+        internal
+        view
+    {
+        // Verify that Ethereum tx signer is the same as the approved txOrigin
+        require(
+            tx.origin == txOrigin,
+            "INVALID_ORIGIN"
+        );
+
+        // Hash 0x transaction
+        bytes32 transactionHash = getTransactionHash(transaction);
+
+        // Create empty list of approval signers
+        address[] memory approvalSignerAddresses = new address[](0);
+
+        uint256 signaturesLength = approvalSignatures.length;
+        for (uint256 i = 0; i != signaturesLength; i++) {
+            // Create approval message
+            uint256 currentApprovalExpirationTimeSeconds = approvalExpirationTimeSeconds[i];
+            CoordinatorApproval memory approval = CoordinatorApproval({
+                txOrigin: txOrigin,
+                transactionHash: transactionHash,
+                transactionSignature: transactionSignature,
+                approvalExpirationTimeSeconds: currentApprovalExpirationTimeSeconds
+            });
+
+            // Ensure approval has not expired
+            require(
+                // solhint-disable-next-line not-rely-on-time
+                currentApprovalExpirationTimeSeconds > block.timestamp,
+                "APPROVAL_EXPIRED"
+            );
+
+            // Hash approval message and recover signer address
+            bytes32 approvalHash = getCoordinatorApprovalHash(approval);
+            address approvalSignerAddress = getSignerAddress(approvalHash, approvalSignatures[i]);
+
+            // Add approval signer to list of signers
+            approvalSignerAddresses = approvalSignerAddresses.append(approvalSignerAddress);
+        }
+
+        // Ethereum transaction signer gives implicit signature of approval
+        approvalSignerAddresses = approvalSignerAddresses.append(tx.origin);
+
+        uint256 ordersLength = orders.length;
+        for (uint256 i = 0; i != ordersLength; i++) {
+            // Do not check approval if the order's senderAddress is null
+            if (orders[i].senderAddress == address(0)) {
+                continue;
+            }
+
+            // Ensure feeRecipient of order has approved this 0x transaction
+            address approverAddress = orders[i].feeRecipientAddress;
+            bool isOrderApproved = approvalSignerAddresses.contains(approverAddress);
+            require(
+                isOrderApproved,
+                "INVALID_APPROVAL_SIGNATURE"
+            );
+        }
+    }
+}

contracts/coordinator/contracts/src/MixinCoordinatorCore.sol

@@ -0,0 +1,65 @@
+/*
+
+  Copyright 2018 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;
+pragma experimental "ABIEncoderV2";
+
+import "./libs/LibZeroExTransaction.sol";
+import "./libs/LibConstants.sol";
+import "./mixins/MCoordinatorApprovalVerifier.sol";
+import "./interfaces/ICoordinatorCore.sol";
+
+
+contract MixinCoordinatorCore is
+    LibConstants,
+    MCoordinatorApprovalVerifier,
+    ICoordinatorCore
+{
+    /// @dev Executes a 0x transaction that has been signed by the feeRecipients that correspond to each order in the transaction's Exchange calldata.
+    /// @param transaction 0x transaction containing salt, signerAddress, and data.
+    /// @param txOrigin Required signer of Ethereum transaction calling this function.
+    /// @param transactionSignature Proof that the transaction has been signed by the signer.
+    /// @param approvalExpirationTimeSeconds Array of expiration times in seconds for which each corresponding approval signature expires.
+    /// @param approvalSignatures Array of signatures that correspond to the feeRecipients of each order in the transaction's Exchange calldata.
+    function executeTransaction(
+        LibZeroExTransaction.ZeroExTransaction memory transaction,
+        address txOrigin,
+        bytes memory transactionSignature,
+        uint256[] memory approvalExpirationTimeSeconds,
+        bytes[] memory approvalSignatures
+    )
+        public
+    {
+        // Validate that the 0x transaction has been approves by each feeRecipient
+        assertValidCoordinatorApprovals(
+            transaction,
+            txOrigin,
+            transactionSignature,
+            approvalExpirationTimeSeconds,
+            approvalSignatures
+        );
+
+        // Execute the transaction
+        EXCHANGE.executeTransaction(
+            transaction.salt,
+            transaction.signerAddress,
+            transaction.data,
+            transactionSignature
+        );
+    }
+}

contracts/coordinator/contracts/src/MixinSignatureValidator.sol

@@ -0,0 +1,118 @@
+/*
+
+  Copyright 2018 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/LibBytes.sol";
+import "./mixins/MSignatureValidator.sol";
+
+
+contract MixinSignatureValidator is
+    MSignatureValidator
+{
+    using LibBytes for bytes;
+
+    /// @dev Recovers the address of a signer given a hash and signature.
+    /// @param hash Any 32 byte hash.
+    /// @param signature Proof that the hash has been signed by signer.
+    function getSignerAddress(bytes32 hash, bytes memory signature)
+        public
+        pure
+        returns (address signerAddress)
+    {
+        require(
+            signature.length > 0,
+            "LENGTH_GREATER_THAN_0_REQUIRED"
+        );
+
+        // Pop last byte off of signature byte array.
+        uint8 signatureTypeRaw = uint8(signature.popLastByte());
+
+        // Ensure signature is supported
+        require(
+            signatureTypeRaw < uint8(SignatureType.NSignatureTypes),
+            "SIGNATURE_UNSUPPORTED"
+        );
+
+        SignatureType signatureType = SignatureType(signatureTypeRaw);
+
+        // Always illegal signature.
+        // This is always an implicit option since a signer can create a
+        // signature array with invalid type or length. We may as well make
+        // it an explicit option. This aids testing and analysis. It is
+        // also the initialization value for the enum type.
+        if (signatureType == SignatureType.Illegal) {
+            revert("SIGNATURE_ILLEGAL");
+
+        // Always invalid signature.
+        // Like Illegal, this is always implicitly available and therefore
+        // offered explicitly. It can be implicitly created by providing
+        // a correctly formatted but incorrect signature.
+        } else if (signatureType == SignatureType.Invalid) {
+            require(
+                signature.length == 0,
+                "LENGTH_0_REQUIRED"
+            );
+            revert("SIGNATURE_INVALID");
+
+        // Signature using EIP712
+        } else if (signatureType == SignatureType.EIP712) {
+            require(
+                signature.length == 65,
+                "LENGTH_65_REQUIRED"
+            );
+            uint8 v = uint8(signature[0]);
+            bytes32 r = signature.readBytes32(1);
+            bytes32 s = signature.readBytes32(33);
+            signerAddress = ecrecover(
+                hash,
+                v,
+                r,
+                s
+            );
+            return signerAddress;
+
+        // Signed using web3.eth_sign
+        } else if (signatureType == SignatureType.EthSign) {
+            require(
+                signature.length == 65,
+                "LENGTH_65_REQUIRED"
+            );
+            uint8 v = uint8(signature[0]);
+            bytes32 r = signature.readBytes32(1);
+            bytes32 s = signature.readBytes32(33);
+            signerAddress = ecrecover(
+                keccak256(abi.encodePacked(
+                    "\x19Ethereum Signed Message:\n32",
+                    hash
+                )),
+                v,
+                r,
+                s
+            );
+            return signerAddress;
+        }
+
+        // Anything else is illegal (We do not return false because
+        // the signature may actually be valid, just not in a format
+        // that we currently support. In this case returning false
+        // may lead the caller to incorrectly believe that the
+        // signature was invalid.)
+        revert("SIGNATURE_UNSUPPORTED");
+    }
+}

contracts/coordinator/contracts/src/interfaces/ICoordinatorApprovalVerifier.sol

@@ -0,0 +1,52 @@
+/*
+
+  Copyright 2018 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;
+pragma experimental "ABIEncoderV2";
+
+import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
+import "../libs/LibZeroExTransaction.sol";
+
+
+contract ICoordinatorApprovalVerifier {
+
+    /// @dev Validates that the 0x transaction has been approved by all of the feeRecipients
+    ///      that correspond to each order in the transaction's Exchange calldata.
+    /// @param transaction 0x transaction containing salt, signerAddress, and data.
+    /// @param txOrigin Required signer of Ethereum transaction calling this function.
+    /// @param transactionSignature Proof that the transaction has been signed by the signer.
+    /// @param approvalExpirationTimeSeconds Array of expiration times in seconds for which each corresponding approval signature expires.
+    /// @param approvalSignatures Array of signatures that correspond to the feeRecipients of each order in the transaction's Exchange calldata.
+    function assertValidCoordinatorApprovals(
+        LibZeroExTransaction.ZeroExTransaction memory transaction,
+        address txOrigin,
+        bytes memory transactionSignature,
+        uint256[] memory approvalExpirationTimeSeconds,
+        bytes[] memory approvalSignatures
+    )
+        public
+        view;
+
+    /// @dev Decodes the orders from Exchange calldata representing any fill method.
+    /// @param data Exchange calldata representing a fill method.
+    /// @return The orders from the Exchange calldata.
+    function decodeOrdersFromFillData(bytes memory data)
+        public
+        pure
+        returns (LibOrder.Order[] memory orders);
+}

contracts/coordinator/contracts/src/interfaces/ICoordinatorCore.sol

@@ -0,0 +1,41 @@
+/*
+
+  Copyright 2018 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;
+pragma experimental "ABIEncoderV2";
+
+import "../libs/LibZeroExTransaction.sol";
+
+
+contract ICoordinatorCore {
+
+    /// @dev Executes a 0x transaction that has been signed by the feeRecipients that correspond to each order in the transaction's Exchange calldata.
+    /// @param transaction 0x transaction containing salt, signerAddress, and data.
+    /// @param txOrigin Required signer of Ethereum transaction calling this function.
+    /// @param transactionSignature Proof that the transaction has been signed by the signer.
+    /// @param approvalExpirationTimeSeconds Array of expiration times in seconds for which each corresponding approval signature expires.
+    /// @param approvalSignatures Array of signatures that correspond to the feeRecipients of each order in the transaction's Exchange calldata.
+    function executeTransaction(
+        LibZeroExTransaction.ZeroExTransaction memory transaction,
+        address txOrigin,
+        bytes memory transactionSignature,
+        uint256[] memory approvalExpirationTimeSeconds,
+        bytes[] memory approvalSignatures
+    )
+        public;
+}

contracts/coordinator/contracts/src/interfaces/ISignatureValidator.sol

@@ -0,0 +1,31 @@
+/*
+
+  Copyright 2018 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;
+
+
+contract ISignatureValidator {
+
+    /// @dev Recovers the address of a signer given a hash and signature.
+    /// @param hash Any 32 byte hash.
+    /// @param signature Proof that the hash has been signed by signer.
+    function getSignerAddress(bytes32 hash, bytes memory signature)
+        public
+        pure
+        returns (address signerAddress);
+}

contracts/coordinator/contracts/src/interfaces/ITransactions.sol

@@ -0,0 +1,35 @@
+/*
+
+  Copyright 2018 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;
+
+
+contract ITransactions {
+
+    /// @dev Executes an exchange method call in the context of signer.
+    /// @param salt Arbitrary number to ensure uniqueness of transaction hash.
+    /// @param signerAddress Address of transaction signer.
+    /// @param data AbiV2 encoded calldata.
+    /// @param signature Proof of signer transaction by signer.
+    function executeTransaction(
+        uint256 salt,
+        address signerAddress,
+        bytes calldata data,
+        bytes calldata signature
+    )
+        external;
+}

contracts/coordinator/contracts/src/libs/LibConstants.sol

@@ -0,0 +1,34 @@
+/*
+
+  Copyright 2018 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 "../interfaces/ITransactions.sol";
+
+
+contract LibConstants {
+
+     // solhint-disable-next-line var-name-mixedcase
+    ITransactions internal EXCHANGE;
+
+    constructor (address _exchange)
+        public
+    {
+        EXCHANGE = ITransactions(_exchange);
+    }
+}

contracts/coordinator/contracts/src/libs/LibCoordinatorApproval.sol

@@ -0,0 +1,98 @@
+/*
+
+  Copyright 2018 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;
+pragma experimental "ABIEncoderV2";
+
+import "./LibEIP712Domain.sol";
+
+
+contract LibCoordinatorApproval is
+    LibEIP712Domain
+{
+    // Hash for the EIP712 Coordinator approval message
+    // keccak256(abi.encodePacked(
+    //     "CoordinatorApproval(",
+    //     "address txOrigin,",
+    //     "bytes32 transactionHash,",
+    //     "bytes transactionSignature,",
+    //     "uint256 approvalExpirationTimeSeconds",
+    //     ")"
+    // ));
+    bytes32 constant internal EIP712_COORDINATOR_APPROVAL_SCHEMA_HASH = 0x2fbcdbaa76bc7589916958ae919dfbef04d23f6bbf26de6ff317b32c6cc01e05;
+
+    struct CoordinatorApproval {
+        address txOrigin;                       // Required signer of Ethereum transaction that is submitting approval.
+        bytes32 transactionHash;                // EIP712 hash of the transaction.
+        bytes transactionSignature;             // Signature of the 0x transaction.
+        uint256 approvalExpirationTimeSeconds;  // Timestamp in seconds for which the approval expires.
+    }
+
+    /// @dev Calculated the EIP712 hash of the Coordinator approval mesasage using the domain separator of this contract.
+    /// @param approval Coordinator approval message containing the transaction hash, transaction signature, and expiration of the approval.
+    /// @return EIP712 hash of the Coordinator approval message with the domain separator of this contract.
+    function getCoordinatorApprovalHash(CoordinatorApproval memory approval)
+        public
+        view
+        returns (bytes32 approvalHash)
+    {
+        approvalHash = hashEIP712CoordinatorMessage(hashCoordinatorApproval(approval));
+        return approvalHash;
+    }
+
+    /// @dev Calculated the EIP712 hash of the Coordinator approval mesasage with no domain separator.
+    /// @param approval Coordinator approval message containing the transaction hash, transaction signature, and expiration of the approval.
+    /// @return EIP712 hash of the Coordinator approval message with no domain separator.
+    function hashCoordinatorApproval(CoordinatorApproval memory approval)
+        internal
+        pure
+        returns (bytes32 result)
+    {
+        bytes32 schemaHash = EIP712_COORDINATOR_APPROVAL_SCHEMA_HASH;
+        bytes memory transactionSignature = approval.transactionSignature;
+        address txOrigin = approval.txOrigin;
+        bytes32 transactionHash = approval.transactionHash;
+        uint256 approvalExpirationTimeSeconds = approval.approvalExpirationTimeSeconds;
+
+        // Assembly for more efficiently computing:
+        // keccak256(abi.encodePacked(
+        //     EIP712_COORDINATOR_APPROVAL_SCHEMA_HASH,
+        //     approval.txOrigin,
+        //     approval.transactionHash,
+        //     keccak256(approval.transactionSignature)
+        //     approval.approvalExpirationTimeSeconds,
+        // ));
+
+        assembly {
+            // Compute hash of transaction signature
+            let transactionSignatureHash := keccak256(add(transactionSignature, 32), mload(transactionSignature))
+
+            // Load free memory pointer
+            let memPtr := mload(64)
+
+            mstore(memPtr, schemaHash)                               // hash of schema
+            mstore(add(memPtr, 32), txOrigin)                        // txOrigin
+            mstore(add(memPtr, 64), transactionHash)                 // transactionHash
+            mstore(add(memPtr, 96), transactionSignatureHash)        // transactionSignatureHash
+            mstore(add(memPtr, 128), approvalExpirationTimeSeconds)  // approvalExpirationTimeSeconds
+            // Compute hash
+            result := keccak256(memPtr, 160)
+        }
+        return result;
+    }
+}

contracts/coordinator/contracts/src/libs/LibEIP712Domain.sol

@@ -0,0 +1,131 @@
+/*
+
+  Copyright 2018 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 "./LibConstants.sol";
+
+
+contract LibEIP712Domain is
+    LibConstants
+{
+
+    // EIP191 header for EIP712 prefix
+    string constant internal EIP191_HEADER = "\x19\x01";
+
+    // EIP712 Domain Name value for the Coordinator
+    string constant internal EIP712_COORDINATOR_DOMAIN_NAME = "0x Protocol Coordinator";
+
+    // EIP712 Domain Version value for the Coordinator
+    string constant internal EIP712_COORDINATOR_DOMAIN_VERSION = "1.0.0";
+
+    // EIP712 Domain Name value for the Exchange
+    string constant internal EIP712_EXCHANGE_DOMAIN_NAME = "0x Protocol";
+
+    // EIP712 Domain Version value for the Exchange
+    string constant internal EIP712_EXCHANGE_DOMAIN_VERSION = "2";
+
+    // Hash of the EIP712 Domain Separator Schema
+    bytes32 constant internal EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = keccak256(abi.encodePacked(
+        "EIP712Domain(",
+        "string name,",
+        "string version,",
+        "address verifyingContract",
+        ")"
+    ));
+
+    // Hash of the EIP712 Domain Separator data for the Coordinator
+    // solhint-disable-next-line var-name-mixedcase
+    bytes32 public EIP712_COORDINATOR_DOMAIN_HASH;
+
+    // Hash of the EIP712 Domain Separator data for the Exchange
+    // solhint-disable-next-line var-name-mixedcase
+    bytes32 public EIP712_EXCHANGE_DOMAIN_HASH;
+
+    constructor ()
+        public
+    {
+        EIP712_COORDINATOR_DOMAIN_HASH = keccak256(abi.encodePacked(
+            EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
+            keccak256(bytes(EIP712_COORDINATOR_DOMAIN_NAME)),
+            keccak256(bytes(EIP712_COORDINATOR_DOMAIN_VERSION)),
+            uint256(address(this))
+        ));
+
+        EIP712_EXCHANGE_DOMAIN_HASH = keccak256(abi.encodePacked(
+            EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
+            keccak256(bytes(EIP712_EXCHANGE_DOMAIN_NAME)),
+            keccak256(bytes(EIP712_EXCHANGE_DOMAIN_VERSION)),
+            uint256(address(EXCHANGE))
+        ));
+    }
+
+    /// @dev Calculates EIP712 encoding for a hash struct in the EIP712 domain
+    ///      of this contract.
+    /// @param hashStruct The EIP712 hash struct.
+    /// @return EIP712 hash applied to this EIP712 Domain.
+    function hashEIP712CoordinatorMessage(bytes32 hashStruct)
+        internal
+        view
+        returns (bytes32 result)
+    {
+        return hashEIP712Message(EIP712_COORDINATOR_DOMAIN_HASH, hashStruct);
+    }
+
+    /// @dev Calculates EIP712 encoding for a hash struct in the EIP712 domain
+    ///      of the Exchange contract.
+    /// @param hashStruct The EIP712 hash struct.
+    /// @return EIP712 hash applied to the Exchange EIP712 Domain.
+    function hashEIP712ExchangeMessage(bytes32 hashStruct)
+        internal
+        view
+        returns (bytes32 result)
+    {
+        return hashEIP712Message(EIP712_EXCHANGE_DOMAIN_HASH, hashStruct);
+    }
+
+    /// @dev Calculates EIP712 encoding for a hash struct with a given domain hash.
+    /// @param eip712DomainHash Hash of the domain domain separator data.
+    /// @param hashStruct The EIP712 hash struct.
+    /// @return EIP712 hash applied to the Exchange 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/coordinator/contracts/src/libs/LibZeroExTransaction.sol

@@ -0,0 +1,95 @@
+/*
+
+  Copyright 2018 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;
+pragma experimental "ABIEncoderV2";
+
+import "./LibEIP712Domain.sol";
+
+
+contract LibZeroExTransaction is
+    LibEIP712Domain
+{
+    // Hash for the EIP712 0x transaction schema
+    // keccak256(abi.encodePacked(
+    //    "ZeroExTransaction(",
+    //    "uint256 salt,",
+    //    "address signerAddress,",
+    //    "bytes data",
+    //    ")"
+    // ));
+    bytes32 constant internal EIP712_ZEROEX_TRANSACTION_SCHEMA_HASH = 0x213c6f636f3ea94e701c0adf9b2624aa45a6c694f9a292c094f9a81c24b5df4c;
+
+    struct ZeroExTransaction {
+        uint256 salt;           // Arbitrary number to ensure uniqueness of transaction hash.
+        address signerAddress;  // Address of transaction signer.
+        bytes data;             // AbiV2 encoded calldata.
+    }
+
+    /// @dev Calculates the EIP712 hash of a 0x transaction using the domain separator of the Exchange contract.
+    /// @param transaction 0x transaction containing salt, signerAddress, and data.
+    /// @return EIP712 hash of the transaction with the domain separator of this contract.
+    function getTransactionHash(ZeroExTransaction memory transaction)
+        public
+        view
+        returns (bytes32 transactionHash)
+    {
+        // Hash the transaction with the domain separator of the Exchange contract.
+        transactionHash = hashEIP712ExchangeMessage(hashZeroExTransaction(transaction));
+        return transactionHash;
+    }
+
+    /// @dev Calculates EIP712 hash of the 0x transaction with no domain separator.
+    /// @param transaction 0x transaction containing salt, signerAddress, and data.
+    /// @return EIP712 hash of the transaction with no domain separator.
+    function hashZeroExTransaction(ZeroExTransaction memory transaction)
+        internal
+        pure
+        returns (bytes32 result)
+    {
+        bytes32 schemaHash = EIP712_ZEROEX_TRANSACTION_SCHEMA_HASH;
+        bytes memory data = transaction.data;
+        uint256 salt = transaction.salt;
+        address signerAddress = transaction.signerAddress;
+
+        // Assembly for more efficiently computing:
+        // keccak256(abi.encodePacked(
+        //     EIP712_ZEROEX_TRANSACTION_SCHEMA_HASH,
+        //     transaction.salt,
+        //     uint256(transaction.signerAddress),
+        //     keccak256(transaction.data)
+        // ));
+
+        assembly {
+            // Compute hash of data
+            let dataHash := keccak256(add(data, 32), mload(data))
+
+            // Load free memory pointer
+            let memPtr := mload(64)
+
+            mstore(memPtr, schemaHash)                                                               // hash of schema
+            mstore(add(memPtr, 32), salt)                                                            // salt
+            mstore(add(memPtr, 64), and(signerAddress, 0xffffffffffffffffffffffffffffffffffffffff))  // signerAddress
+            mstore(add(memPtr, 96), dataHash)                                                        // hash of data
+
+            // Compute hash
+            result := keccak256(memPtr, 128)
+        }
+        return result;
+    }
+}

contracts/coordinator/contracts/src/mixins/MCoordinatorApprovalVerifier.sol

@@ -0,0 +1,46 @@
+/*
+
+  Copyright 2018 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;
+pragma experimental "ABIEncoderV2";
+
+import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
+import "../interfaces/ICoordinatorApprovalVerifier.sol";
+
+
+contract MCoordinatorApprovalVerifier is
+    ICoordinatorApprovalVerifier
+{
+    /// @dev Validates that the feeRecipients of a batch of order have approved a 0x transaction.
+    /// @param transaction 0x transaction containing salt, signerAddress, and data.
+    /// @param orders Array of order structs containing order specifications.
+    /// @param txOrigin Required signer of Ethereum transaction calling this function.
+    /// @param transactionSignature Proof that the transaction has been signed by the signer.
+    /// @param approvalExpirationTimeSeconds Array of expiration times in seconds for which each corresponding approval signature expires.
+    /// @param approvalSignatures Array of signatures that correspond to the feeRecipients of each order.
+    function assertValidTransactionOrdersApproval(
+        LibZeroExTransaction.ZeroExTransaction memory transaction,
+        LibOrder.Order[] memory orders,
+        address txOrigin,
+        bytes memory transactionSignature,
+        uint256[] memory approvalExpirationTimeSeconds,
+        bytes[] memory approvalSignatures
+    )
+        internal
+        view;
+}

contracts/coordinator/contracts/src/mixins/MSignatureValidator.sol

@@ -0,0 +1,35 @@
+/*
+
+  Copyright 2018 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 "../interfaces/ISignatureValidator.sol";
+
+
+contract MSignatureValidator is
+    ISignatureValidator
+{
+    // Allowed signature types.
+    enum SignatureType {
+        Illegal,         // 0x00, default value
+        Invalid,         // 0x01
+        EIP712,          // 0x02
+        EthSign,         // 0x03
+        NSignatureTypes  // 0x04, number of signature types. Always leave at end.
+    }
+}

contracts/coordinator/contracts/src/registry/CoordinatorRegistry.sol

@@ -0,0 +1,32 @@
+/*
+
+  Copyright 2018 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 "./MixinCoordinatorRegistryCore.sol";
+
+
+// solhint-disable no-empty-blocks
+contract CoordinatorRegistry is
+    MixinCoordinatorRegistryCore
+{
+    constructor ()
+        public
+        MixinCoordinatorRegistryCore()
+    {}
+}

contracts/coordinator/contracts/src/registry/MixinCoordinatorRegistryCore.sol

@@ -0,0 +1,48 @@
+/*
+
+  Copyright 2018 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 "./interfaces/ICoordinatorRegistryCore.sol";
+
+
+// solhint-disable no-empty-blocks
+contract MixinCoordinatorRegistryCore is
+    ICoordinatorRegistryCore
+{
+    // mapping from `coordinatorOperator` -> `coordinatorEndpoint`
+    mapping (address => string) internal coordinatorEndpoints;
+
+    /// @dev Called by a Coordinator operator to set the endpoint of their Coordinator.
+    /// @param coordinatorEndpoint endpoint of the Coordinator.
+    function setCoordinatorEndpoint(string calldata coordinatorEndpoint) external {
+        address coordinatorOperator = msg.sender;
+        coordinatorEndpoints[coordinatorOperator] = coordinatorEndpoint;
+        emit CoordinatorEndpointSet(coordinatorOperator, coordinatorEndpoint);
+    }
+
+    /// @dev Gets the endpoint for a Coordinator.
+    /// @param coordinatorOperator operator of the Coordinator endpoint.
+    function getCoordinatorEndpoint(address coordinatorOperator)
+        external
+        view
+        returns (string memory coordinatorEndpoint)
+    {
+        return coordinatorEndpoints[coordinatorOperator];
+    }
+}

contracts/coordinator/contracts/src/registry/interfaces/ICoordinatorRegistryCore.sol

@@ -0,0 +1,41 @@
+/*
+
+  Copyright 2018 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;
+
+
+// solhint-disable no-empty-blocks
+contract ICoordinatorRegistryCore
+{
+    /// @dev Emitted when a Coordinator endpoint is set.
+    event CoordinatorEndpointSet(
+        address coordinatorOperator,
+        string coordinatorEndpoint
+    );
+
+    /// @dev Called by a Coordinator operator to set the endpoint of their Coordinator.
+    /// @param coordinatorEndpoint endpoint of the Coordinator.
+    function setCoordinatorEndpoint(string calldata coordinatorEndpoint) external;
+
+    /// @dev Gets the endpoint for a Coordinator.
+    /// @param coordinatorOperator operator of the Coordinator endpoint.
+    function getCoordinatorEndpoint(address coordinatorOperator)
+        external
+        view
+        returns (string memory coordinatorEndpoint);
+}

contracts/coordinator/package.json

@@ -0,0 +1,90 @@
+{
+    "name": "@0x/contracts-coordinator",
+    "version": "2.0.9",
+    "engines": {
+        "node": ">=6.12"
+    },
+    "description": "Smart contract extensions of 0x protocol",
+    "main": "lib/src/index.js",
+    "directories": {
+        "test": "test"
+    },
+    "scripts": {
+        "build": "yarn pre_build && tsc -b",
+        "build:ci": "yarn build",
+        "pre_build": "run-s compile generate_contract_wrappers",
+        "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 generated-artifacts generated-wrappers",
+        "generate_contract_wrappers": "abi-gen --abis  ${npm_package_config_abis} --template ../../node_modules/@0x/abi-gen-templates/contract.handlebars --partials '../../node_modules/@0x/abi-gen-templates/partials/**/*.handlebars' --output generated-wrappers --backend ethers",
+        "lint": "tslint --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
+        "fix": "tslint --fix --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
+        "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",
+        "lint-contracts": "solhint -c ../.solhint.json contracts/**/**/**/**/*.sol"
+    },
+    "config": {
+        "abis": "./generated-artifacts/@(Coordinator|CoordinatorRegistry).json",
+        "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually."
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/0xProject/0x-monorepo.git"
+    },
+    "license": "Apache-2.0",
+    "bugs": {
+        "url": "https://github.com/0xProject/0x-monorepo/issues"
+    },
+    "homepage": "https://github.com/0xProject/0x-monorepo/contracts/extensions/README.md",
+    "devDependencies": {
+        "@0x/abi-gen": "^3.1.2",
+        "@0x/contracts-gen": "^1.0.12",
+        "@0x/contracts-test-utils": "^3.1.12",
+        "@0x/dev-utils": "^2.2.6",
+        "@0x/sol-compiler": "^3.1.11",
+        "@0x/tslint-config": "^3.0.1",
+        "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
+        "@types/node": "*",
+        "chai": "^4.0.1",
+        "chai-as-promised": "^7.1.0",
+        "chai-bignumber": "^3.0.0",
+        "dirty-chai": "^2.0.1",
+        "make-promises-safe": "^1.1.0",
+        "mocha": "^6.2.0",
+        "npm-run-all": "^4.1.2",
+        "shx": "^0.2.2",
+        "solhint": "^1.4.1",
+        "tslint": "5.11.0",
+        "typescript": "3.0.1"
+    },
+    "dependencies": {
+        "@0x/base-contract": "^5.3.0",
+        "@0x/contracts-asset-proxy": "^2.2.4",
+        "@0x/contracts-erc20": "^2.2.10",
+        "@0x/contracts-exchange": "^2.1.10",
+        "@0x/contracts-exchange-libs": "^3.0.4",
+        "@0x/contracts-utils": "^3.2.0",
+        "@0x/order-utils": "^8.2.4",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.4.2",
+        "@0x/web3-wrapper": "^6.0.9",
+        "ethereum-types": "^2.1.4",
+        "ethereumjs-util": "^5.1.1",
+        "lodash": "^4.17.11"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

contracts/coordinator/src/artifacts.ts

@@ -0,0 +1,13 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+import { ContractArtifact } from 'ethereum-types';
+
+import * as Coordinator from '../generated-artifacts/Coordinator.json';
+import * as CoordinatorRegistry from '../generated-artifacts/CoordinatorRegistry.json';
+export const artifacts = {
+    Coordinator: Coordinator as ContractArtifact,
+    CoordinatorRegistry: CoordinatorRegistry as ContractArtifact,
+};

contracts/coordinator/src/index.ts

@@ -0,0 +1,3 @@
+export * from './artifacts';
+export * from './wrappers';
+export * from '../test/utils';

contracts/coordinator/src/wrappers.ts

@@ -0,0 +1,7 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+export * from '../generated-wrappers/coordinator';
+export * from '../generated-wrappers/coordinator_registry';

contracts/coordinator/test/coordinator.ts

@@ -0,0 +1,523 @@
+import { ERC20ProxyContract, ERC20Wrapper } from '@0x/contracts-asset-proxy';
+import { DummyERC20TokenContract } from '@0x/contracts-erc20';
+import {
+    artifacts as exchangeArtifacts,
+    ExchangeCancelEventArgs,
+    ExchangeCancelUpToEventArgs,
+    ExchangeContract,
+    ExchangeFillEventArgs,
+} from '@0x/contracts-exchange';
+import {
+    chaiSetup,
+    constants as devConstants,
+    expectTransactionFailedAsync,
+    getLatestBlockTimestampAsync,
+    OrderFactory,
+    provider,
+    TransactionFactory,
+    txDefaults,
+    web3Wrapper,
+} from '@0x/contracts-test-utils';
+import { BlockchainLifecycle } from '@0x/dev-utils';
+import { assetDataUtils, orderHashUtils } from '@0x/order-utils';
+import { RevertReason, SignedOrder } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+import * as chai from 'chai';
+import { LogWithDecodedArgs } from 'ethereum-types';
+
+import { ApprovalFactory, artifacts, constants, CoordinatorContract, exchangeDataEncoder } from '../src';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+web3Wrapper.abiDecoder.addABI(exchangeArtifacts.Exchange.compilerOutput.abi);
+// tslint:disable:no-unnecessary-type-assertion
+describe('Coordinator tests', () => {
+    let makerAddress: string;
+    let owner: string;
+    let takerAddress: string;
+    let feeRecipientAddress: string;
+
+    let erc20Proxy: ERC20ProxyContract;
+    let erc20TokenA: DummyERC20TokenContract;
+    let erc20TokenB: DummyERC20TokenContract;
+    let zrxToken: DummyERC20TokenContract;
+    let coordinatorContract: CoordinatorContract;
+    let exchange: ExchangeContract;
+
+    let erc20Wrapper: ERC20Wrapper;
+    let orderFactory: OrderFactory;
+    let takerTransactionFactory: TransactionFactory;
+    let makerTransactionFactory: TransactionFactory;
+    let approvalFactory: ApprovalFactory;
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    before(async () => {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        const usedAddresses = ([owner, makerAddress, takerAddress, feeRecipientAddress] = accounts.slice(0, 4));
+
+        erc20Wrapper = new ERC20Wrapper(provider, usedAddresses, owner);
+        erc20Proxy = await erc20Wrapper.deployProxyAsync();
+        const numDummyErc20ToDeploy = 3;
+        [erc20TokenA, erc20TokenB, zrxToken] = await erc20Wrapper.deployDummyTokensAsync(
+            numDummyErc20ToDeploy,
+            devConstants.DUMMY_TOKEN_DECIMALS,
+        );
+        await erc20Wrapper.setBalancesAndAllowancesAsync();
+
+        exchange = await ExchangeContract.deployFrom0xArtifactAsync(
+            exchangeArtifacts.Exchange,
+            provider,
+            txDefaults,
+            artifacts,
+            assetDataUtils.encodeERC20AssetData(zrxToken.address),
+        );
+
+        await web3Wrapper.awaitTransactionSuccessAsync(
+            await erc20Proxy.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: owner }),
+            devConstants.AWAIT_TRANSACTION_MINED_MS,
+        );
+
+        await web3Wrapper.awaitTransactionSuccessAsync(
+            await exchange.registerAssetProxy.sendTransactionAsync(erc20Proxy.address, { from: owner }),
+            devConstants.AWAIT_TRANSACTION_MINED_MS,
+        );
+
+        coordinatorContract = await CoordinatorContract.deployFrom0xArtifactAsync(
+            artifacts.Coordinator,
+            provider,
+            txDefaults,
+            artifacts,
+            exchange.address,
+        );
+
+        // Configure order defaults
+        const defaultOrderParams = {
+            ...devConstants.STATIC_ORDER_PARAMS,
+            exchangeAddress: exchange.address,
+            senderAddress: coordinatorContract.address,
+            makerAddress,
+            feeRecipientAddress,
+            makerAssetData: assetDataUtils.encodeERC20AssetData(erc20TokenA.address),
+            takerAssetData: assetDataUtils.encodeERC20AssetData(erc20TokenB.address),
+        };
+        const makerPrivateKey = devConstants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
+        const takerPrivateKey = devConstants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(takerAddress)];
+        const feeRecipientPrivateKey = devConstants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(feeRecipientAddress)];
+        orderFactory = new OrderFactory(makerPrivateKey, defaultOrderParams);
+        makerTransactionFactory = new TransactionFactory(makerPrivateKey, exchange.address);
+        takerTransactionFactory = new TransactionFactory(takerPrivateKey, exchange.address);
+        approvalFactory = new ApprovalFactory(feeRecipientPrivateKey, coordinatorContract.address);
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    describe('single order fills', () => {
+        for (const fnName of constants.SINGLE_FILL_FN_NAMES) {
+            it(`${fnName} should fill the order with a signed approval`, async () => {
+                const orders = [await orderFactory.newSignedOrderAsync()];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = takerTransactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory.newSignedApproval(
+                    transaction,
+                    takerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                const transactionReceipt = await web3Wrapper.awaitTransactionSuccessAsync(
+                    await coordinatorContract.executeTransaction.sendTransactionAsync(
+                        transaction,
+                        takerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [approval.signature],
+                        { from: takerAddress },
+                    ),
+                    devConstants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const fillLogs = transactionReceipt.logs.filter(
+                    log => (log as LogWithDecodedArgs<ExchangeFillEventArgs>).event === 'Fill',
+                );
+                expect(fillLogs.length).to.eq(1);
+                const fillLogArgs = (fillLogs[0] as LogWithDecodedArgs<ExchangeFillEventArgs>).args;
+                expect(fillLogArgs.makerAddress).to.eq(makerAddress);
+                expect(fillLogArgs.takerAddress).to.eq(takerAddress);
+                expect(fillLogArgs.senderAddress).to.eq(coordinatorContract.address);
+                expect(fillLogArgs.feeRecipientAddress).to.eq(feeRecipientAddress);
+                expect(fillLogArgs.makerAssetData).to.eq(orders[0].makerAssetData);
+                expect(fillLogArgs.takerAssetData).to.eq(orders[0].takerAssetData);
+                expect(fillLogArgs.makerAssetFilledAmount).to.bignumber.eq(orders[0].makerAssetAmount);
+                expect(fillLogArgs.takerAssetFilledAmount).to.bignumber.eq(orders[0].takerAssetAmount);
+                expect(fillLogArgs.makerFeePaid).to.bignumber.eq(orders[0].makerFee);
+                expect(fillLogArgs.takerFeePaid).to.bignumber.eq(orders[0].takerFee);
+                expect(fillLogArgs.orderHash).to.eq(orderHashUtils.getOrderHashHex(orders[0]));
+            });
+            it(`${fnName} should fill the order if called by approver`, async () => {
+                const orders = [await orderFactory.newSignedOrderAsync()];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = takerTransactionFactory.newSignedTransaction(data);
+                const transactionReceipt = await web3Wrapper.awaitTransactionSuccessAsync(
+                    await coordinatorContract.executeTransaction.sendTransactionAsync(
+                        transaction,
+                        feeRecipientAddress,
+                        transaction.signature,
+                        [],
+                        [],
+                        { from: feeRecipientAddress },
+                    ),
+                    devConstants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const fillLogs = transactionReceipt.logs.filter(
+                    log => (log as LogWithDecodedArgs<ExchangeFillEventArgs>).event === 'Fill',
+                );
+                expect(fillLogs.length).to.eq(1);
+                const fillLogArgs = (fillLogs[0] as LogWithDecodedArgs<ExchangeFillEventArgs>).args;
+                expect(fillLogArgs.makerAddress).to.eq(makerAddress);
+                expect(fillLogArgs.takerAddress).to.eq(takerAddress);
+                expect(fillLogArgs.senderAddress).to.eq(coordinatorContract.address);
+                expect(fillLogArgs.feeRecipientAddress).to.eq(feeRecipientAddress);
+                expect(fillLogArgs.makerAssetData).to.eq(orders[0].makerAssetData);
+                expect(fillLogArgs.takerAssetData).to.eq(orders[0].takerAssetData);
+                expect(fillLogArgs.makerAssetFilledAmount).to.bignumber.eq(orders[0].makerAssetAmount);
+                expect(fillLogArgs.takerAssetFilledAmount).to.bignumber.eq(orders[0].takerAssetAmount);
+                expect(fillLogArgs.makerFeePaid).to.bignumber.eq(orders[0].makerFee);
+                expect(fillLogArgs.takerFeePaid).to.bignumber.eq(orders[0].takerFee);
+                expect(fillLogArgs.orderHash).to.eq(orderHashUtils.getOrderHashHex(orders[0]));
+            });
+            it(`${fnName} should revert with no approval signature`, async () => {
+                const orders = [await orderFactory.newSignedOrderAsync()];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = takerTransactionFactory.newSignedTransaction(data);
+                await expectTransactionFailedAsync(
+                    coordinatorContract.executeTransaction.sendTransactionAsync(
+                        transaction,
+                        takerAddress,
+                        transaction.signature,
+                        [],
+                        [],
+                        {
+                            from: takerAddress,
+                            gas: devConstants.MAX_EXECUTE_TRANSACTION_GAS,
+                        },
+                    ),
+                    RevertReason.InvalidApprovalSignature,
+                );
+            });
+            it(`${fnName} should revert with an invalid approval signature`, async () => {
+                const orders = [await orderFactory.newSignedOrderAsync()];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = takerTransactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory.newSignedApproval(
+                    transaction,
+                    takerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                const signature = `${approval.signature.slice(0, 4)}FFFFFFFF${approval.signature.slice(12)}`;
+                await expectTransactionFailedAsync(
+                    coordinatorContract.executeTransaction.sendTransactionAsync(
+                        transaction,
+                        takerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [signature],
+                        { from: takerAddress },
+                    ),
+                    RevertReason.InvalidApprovalSignature,
+                );
+            });
+            it(`${fnName} should revert with an expired approval`, async () => {
+                const orders = [await orderFactory.newSignedOrderAsync()];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = takerTransactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).minus(constants.TIME_BUFFER);
+                const approval = approvalFactory.newSignedApproval(
+                    transaction,
+                    takerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                await expectTransactionFailedAsync(
+                    coordinatorContract.executeTransaction.sendTransactionAsync(
+                        transaction,
+                        takerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [approval.signature],
+                        { from: takerAddress },
+                    ),
+                    RevertReason.ApprovalExpired,
+                );
+            });
+            it(`${fnName} should revert if not called by tx signer or approver`, async () => {
+                const orders = [await orderFactory.newSignedOrderAsync()];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = takerTransactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory.newSignedApproval(
+                    transaction,
+                    takerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                await expectTransactionFailedAsync(
+                    coordinatorContract.executeTransaction.sendTransactionAsync(
+                        transaction,
+                        takerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [approval.signature],
+                        { from: owner },
+                    ),
+                    RevertReason.InvalidOrigin,
+                );
+            });
+        }
+    });
+    describe('batch order fills', () => {
+        for (const fnName of [...constants.MARKET_FILL_FN_NAMES, ...constants.BATCH_FILL_FN_NAMES]) {
+            it(`${fnName} should fill the orders with a signed approval`, async () => {
+                const orders = [await orderFactory.newSignedOrderAsync(), await orderFactory.newSignedOrderAsync()];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = takerTransactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory.newSignedApproval(
+                    transaction,
+                    takerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                const transactionReceipt = await web3Wrapper.awaitTransactionSuccessAsync(
+                    await coordinatorContract.executeTransaction.sendTransactionAsync(
+                        transaction,
+                        takerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [approval.signature],
+                        { from: takerAddress, gas: devConstants.MAX_EXECUTE_TRANSACTION_GAS },
+                    ),
+                    devConstants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const fillLogs = transactionReceipt.logs.filter(
+                    log => (log as LogWithDecodedArgs<ExchangeFillEventArgs>).event === 'Fill',
+                );
+                expect(fillLogs.length).to.eq(orders.length);
+                orders.forEach((order, index) => {
+                    const fillLogArgs = (fillLogs[index] as LogWithDecodedArgs<ExchangeFillEventArgs>).args;
+                    expect(fillLogArgs.makerAddress).to.eq(makerAddress);
+                    expect(fillLogArgs.takerAddress).to.eq(takerAddress);
+                    expect(fillLogArgs.senderAddress).to.eq(coordinatorContract.address);
+                    expect(fillLogArgs.feeRecipientAddress).to.eq(feeRecipientAddress);
+                    expect(fillLogArgs.makerAssetData).to.eq(order.makerAssetData);
+                    expect(fillLogArgs.takerAssetData).to.eq(order.takerAssetData);
+                    expect(fillLogArgs.makerAssetFilledAmount).to.bignumber.eq(order.makerAssetAmount);
+                    expect(fillLogArgs.takerAssetFilledAmount).to.bignumber.eq(order.takerAssetAmount);
+                    expect(fillLogArgs.makerFeePaid).to.bignumber.eq(order.makerFee);
+                    expect(fillLogArgs.takerFeePaid).to.bignumber.eq(order.takerFee);
+                    expect(fillLogArgs.orderHash).to.eq(orderHashUtils.getOrderHashHex(order));
+                });
+            });
+            it(`${fnName} should fill the orders if called by approver`, async () => {
+                const orders = [await orderFactory.newSignedOrderAsync(), await orderFactory.newSignedOrderAsync()];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = takerTransactionFactory.newSignedTransaction(data);
+                const transactionReceipt = await web3Wrapper.awaitTransactionSuccessAsync(
+                    await coordinatorContract.executeTransaction.sendTransactionAsync(
+                        transaction,
+                        feeRecipientAddress,
+                        transaction.signature,
+                        [],
+                        [],
+                        { from: feeRecipientAddress, gas: devConstants.MAX_EXECUTE_TRANSACTION_GAS },
+                    ),
+                    devConstants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const fillLogs = transactionReceipt.logs.filter(
+                    log => (log as LogWithDecodedArgs<ExchangeFillEventArgs>).event === 'Fill',
+                );
+                expect(fillLogs.length).to.eq(orders.length);
+                orders.forEach((order, index) => {
+                    const fillLogArgs = (fillLogs[index] as LogWithDecodedArgs<ExchangeFillEventArgs>).args;
+                    expect(fillLogArgs.makerAddress).to.eq(makerAddress);
+                    expect(fillLogArgs.takerAddress).to.eq(takerAddress);
+                    expect(fillLogArgs.senderAddress).to.eq(coordinatorContract.address);
+                    expect(fillLogArgs.feeRecipientAddress).to.eq(feeRecipientAddress);
+                    expect(fillLogArgs.makerAssetData).to.eq(order.makerAssetData);
+                    expect(fillLogArgs.takerAssetData).to.eq(order.takerAssetData);
+                    expect(fillLogArgs.makerAssetFilledAmount).to.bignumber.eq(order.makerAssetAmount);
+                    expect(fillLogArgs.takerAssetFilledAmount).to.bignumber.eq(order.takerAssetAmount);
+                    expect(fillLogArgs.makerFeePaid).to.bignumber.eq(order.makerFee);
+                    expect(fillLogArgs.takerFeePaid).to.bignumber.eq(order.takerFee);
+                    expect(fillLogArgs.orderHash).to.eq(orderHashUtils.getOrderHashHex(order));
+                });
+            });
+            it(`${fnName} should revert with an invalid approval signature`, async () => {
+                const orders = [await orderFactory.newSignedOrderAsync(), await orderFactory.newSignedOrderAsync()];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = takerTransactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory.newSignedApproval(
+                    transaction,
+                    takerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                const signature = `${approval.signature.slice(0, 4)}FFFFFFFF${approval.signature.slice(12)}`;
+                await expectTransactionFailedAsync(
+                    coordinatorContract.executeTransaction.sendTransactionAsync(
+                        transaction,
+                        takerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [signature],
+                        { from: takerAddress },
+                    ),
+                    RevertReason.InvalidApprovalSignature,
+                );
+            });
+            it(`${fnName} should revert with an expired approval`, async () => {
+                const orders = [await orderFactory.newSignedOrderAsync(), await orderFactory.newSignedOrderAsync()];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = takerTransactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).minus(constants.TIME_BUFFER);
+                const approval = approvalFactory.newSignedApproval(
+                    transaction,
+                    takerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                await expectTransactionFailedAsync(
+                    coordinatorContract.executeTransaction.sendTransactionAsync(
+                        transaction,
+                        takerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [approval.signature],
+                        { from: takerAddress },
+                    ),
+                    RevertReason.ApprovalExpired,
+                );
+            });
+            it(`${fnName} should revert if not called by tx signer or approver`, async () => {
+                const orders = [await orderFactory.newSignedOrderAsync(), await orderFactory.newSignedOrderAsync()];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = takerTransactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory.newSignedApproval(
+                    transaction,
+                    takerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                await expectTransactionFailedAsync(
+                    coordinatorContract.executeTransaction.sendTransactionAsync(
+                        transaction,
+                        takerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [approval.signature],
+                        { from: owner },
+                    ),
+                    RevertReason.InvalidOrigin,
+                );
+            });
+        }
+    });
+    describe('cancels', () => {
+        it('cancelOrder call should be successful without an approval', async () => {
+            const orders = [await orderFactory.newSignedOrderAsync()];
+            const data = exchangeDataEncoder.encodeOrdersToExchangeData(constants.CANCEL_ORDER, orders);
+            const transaction = makerTransactionFactory.newSignedTransaction(data);
+            const transactionReceipt = await web3Wrapper.awaitTransactionSuccessAsync(
+                await coordinatorContract.executeTransaction.sendTransactionAsync(
+                    transaction,
+                    makerAddress,
+                    transaction.signature,
+                    [],
+                    [],
+                    {
+                        from: makerAddress,
+                    },
+                ),
+            );
+            const cancelLogs = transactionReceipt.logs.filter(
+                log => (log as LogWithDecodedArgs<ExchangeCancelEventArgs>).event === 'Cancel',
+            );
+            expect(cancelLogs.length).to.eq(1);
+            const cancelLogArgs = (cancelLogs[0] as LogWithDecodedArgs<ExchangeCancelEventArgs>).args;
+            expect(cancelLogArgs.makerAddress).to.eq(makerAddress);
+            expect(cancelLogArgs.senderAddress).to.eq(coordinatorContract.address);
+            expect(cancelLogArgs.feeRecipientAddress).to.eq(feeRecipientAddress);
+            expect(cancelLogArgs.makerAssetData).to.eq(orders[0].makerAssetData);
+            expect(cancelLogArgs.takerAssetData).to.eq(orders[0].takerAssetData);
+            expect(cancelLogArgs.orderHash).to.eq(orderHashUtils.getOrderHashHex(orders[0]));
+        });
+        it('batchCancelOrders call should be successful without an approval', async () => {
+            const orders = [await orderFactory.newSignedOrderAsync(), await orderFactory.newSignedOrderAsync()];
+            const data = exchangeDataEncoder.encodeOrdersToExchangeData(constants.BATCH_CANCEL_ORDERS, orders);
+            const transaction = makerTransactionFactory.newSignedTransaction(data);
+            const transactionReceipt = await web3Wrapper.awaitTransactionSuccessAsync(
+                await coordinatorContract.executeTransaction.sendTransactionAsync(
+                    transaction,
+                    makerAddress,
+                    transaction.signature,
+                    [],
+                    [],
+                    {
+                        from: makerAddress,
+                    },
+                ),
+            );
+            const cancelLogs = transactionReceipt.logs.filter(
+                log => (log as LogWithDecodedArgs<ExchangeCancelEventArgs>).event === 'Cancel',
+            );
+            expect(cancelLogs.length).to.eq(orders.length);
+            orders.forEach((order, index) => {
+                const cancelLogArgs = (cancelLogs[index] as LogWithDecodedArgs<ExchangeCancelEventArgs>).args;
+                expect(cancelLogArgs.makerAddress).to.eq(makerAddress);
+                expect(cancelLogArgs.senderAddress).to.eq(coordinatorContract.address);
+                expect(cancelLogArgs.feeRecipientAddress).to.eq(feeRecipientAddress);
+                expect(cancelLogArgs.makerAssetData).to.eq(order.makerAssetData);
+                expect(cancelLogArgs.takerAssetData).to.eq(order.takerAssetData);
+                expect(cancelLogArgs.orderHash).to.eq(orderHashUtils.getOrderHashHex(order));
+            });
+        });
+        it('cancelOrdersUpTo call should be successful without an approval', async () => {
+            const orders: SignedOrder[] = [];
+            const data = exchangeDataEncoder.encodeOrdersToExchangeData(constants.CANCEL_ORDERS_UP_TO, orders);
+            const transaction = makerTransactionFactory.newSignedTransaction(data);
+            const transactionReceipt = await web3Wrapper.awaitTransactionSuccessAsync(
+                await coordinatorContract.executeTransaction.sendTransactionAsync(
+                    transaction,
+                    makerAddress,
+                    transaction.signature,
+                    [],
+                    [],
+                    {
+                        from: makerAddress,
+                    },
+                ),
+            );
+            const cancelLogs = transactionReceipt.logs.filter(
+                log => (log as LogWithDecodedArgs<ExchangeCancelUpToEventArgs>).event === 'CancelUpTo',
+            );
+            expect(cancelLogs.length).to.eq(1);
+            const cancelLogArgs = (cancelLogs[0] as LogWithDecodedArgs<ExchangeCancelUpToEventArgs>).args;
+            expect(cancelLogArgs.makerAddress).to.eq(makerAddress);
+            expect(cancelLogArgs.senderAddress).to.eq(coordinatorContract.address);
+            expect(cancelLogArgs.orderEpoch).to.bignumber.eq(new BigNumber(1));
+        });
+    });
+});
+// tslint:disable:max-file-line-count

contracts/coordinator/test/coordinator_registry.ts

@@ -0,0 +1,81 @@
+import { artifacts as exchangeArtifacts } from '@0x/contracts-exchange';
+import { chaiSetup, provider, web3Wrapper } from '@0x/contracts-test-utils';
+import { BlockchainLifecycle } from '@0x/dev-utils';
+import * as chai from 'chai';
+import { LogWithDecodedArgs } from 'ethereum-types';
+
+import { CoordinatorRegistryCoordinatorEndpointSetEventArgs } from '../src';
+
+import { CoordinatorRegistryWrapper } from './utils/coordinator_registry_wrapper';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+web3Wrapper.abiDecoder.addABI(exchangeArtifacts.Exchange.compilerOutput.abi);
+// tslint:disable:no-unnecessary-type-assertion
+describe('Coordinator Registry tests', () => {
+    let coordinatorOperator: string;
+    const coordinatorEndpoint = 'http://sometec.0x.org';
+    const nilCoordinatorEndpoint = '';
+    let coordinatorRegistryWrapper: CoordinatorRegistryWrapper;
+    // tests
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    before(async () => {
+        // setup accounts (skip owner)
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        [, coordinatorOperator] = accounts;
+        // deploy coordinator registry
+        coordinatorRegistryWrapper = new CoordinatorRegistryWrapper(provider);
+        await coordinatorRegistryWrapper.deployCoordinatorRegistryAsync();
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('core', () => {
+        it('Should successfully set a Coordinator endpoint', async () => {
+            await coordinatorRegistryWrapper.setCoordinatorEndpointAsync(coordinatorOperator, coordinatorEndpoint);
+            const recordedCoordinatorEndpoint = await coordinatorRegistryWrapper.getCoordinatorEndpointAsync(
+                coordinatorOperator,
+            );
+            expect(recordedCoordinatorEndpoint).to.be.equal(coordinatorEndpoint);
+        });
+        it('Should successfully unset a Coordinator endpoint', async () => {
+            // set Coordinator endpoint
+            await coordinatorRegistryWrapper.setCoordinatorEndpointAsync(coordinatorOperator, coordinatorEndpoint);
+            let recordedCoordinatorEndpoint = await coordinatorRegistryWrapper.getCoordinatorEndpointAsync(
+                coordinatorOperator,
+            );
+            expect(recordedCoordinatorEndpoint).to.be.equal(coordinatorEndpoint);
+            // unset Coordinator endpoint
+            await coordinatorRegistryWrapper.setCoordinatorEndpointAsync(coordinatorOperator, nilCoordinatorEndpoint);
+            recordedCoordinatorEndpoint = await coordinatorRegistryWrapper.getCoordinatorEndpointAsync(
+                coordinatorOperator,
+            );
+            expect(recordedCoordinatorEndpoint).to.be.equal(nilCoordinatorEndpoint);
+        });
+        it('Should emit an event when setting Coordinator endpoint', async () => {
+            // set Coordinator endpoint
+            const txReceipt = await coordinatorRegistryWrapper.setCoordinatorEndpointAsync(
+                coordinatorOperator,
+                coordinatorEndpoint,
+            );
+            const recordedCoordinatorEndpoint = await coordinatorRegistryWrapper.getCoordinatorEndpointAsync(
+                coordinatorOperator,
+            );
+            expect(recordedCoordinatorEndpoint).to.be.equal(coordinatorEndpoint);
+            // validate event
+            expect(txReceipt.logs.length).to.be.equal(1);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<CoordinatorRegistryCoordinatorEndpointSetEventArgs>;
+            expect(log.args.coordinatorOperator).to.be.equal(coordinatorOperator);
+            expect(log.args.coordinatorEndpoint).to.be.equal(coordinatorEndpoint);
+        });
+    });
+});

contracts/coordinator/test/global_hooks.ts

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

contracts/coordinator/test/libs.ts

@@ -0,0 +1,80 @@
+import { addressUtils, chaiSetup, constants, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
+import { BlockchainLifecycle } from '@0x/dev-utils';
+import { transactionHashUtils } from '@0x/order-utils';
+import { BigNumber } from '@0x/utils';
+import * as chai from 'chai';
+
+import { artifacts, CoordinatorContract, hashUtils } from '../src';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+describe('Libs tests', () => {
+    let coordinatorContract: CoordinatorContract;
+    const exchangeAddress = addressUtils.generatePseudoRandomAddress();
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    before(async () => {
+        coordinatorContract = await CoordinatorContract.deployFrom0xArtifactAsync(
+            artifacts.Coordinator,
+            provider,
+            txDefaults,
+            artifacts,
+            exchangeAddress,
+        );
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    describe('getTransactionHash', () => {
+        it('should return the correct transaction hash', async () => {
+            const tx = {
+                verifyingContractAddress: exchangeAddress,
+                salt: new BigNumber(0),
+                signerAddress: constants.NULL_ADDRESS,
+                data: '0x1234',
+            };
+            const expectedTxHash = transactionHashUtils.getTransactionHashHex(tx);
+            const txHash = await coordinatorContract.getTransactionHash.callAsync(tx);
+            expect(expectedTxHash).to.eq(txHash);
+        });
+    });
+
+    describe('getApprovalHash', () => {
+        it('should return the correct approval hash', async () => {
+            const signedTx = {
+                verifyingContractAddress: exchangeAddress,
+                salt: new BigNumber(0),
+                signerAddress: constants.NULL_ADDRESS,
+                data: '0x1234',
+                signature: '0x5678',
+            };
+            const approvalExpirationTimeSeconds = new BigNumber(0);
+            const txOrigin = constants.NULL_ADDRESS;
+            const approval = {
+                txOrigin,
+                transactionHash: transactionHashUtils.getTransactionHashHex(signedTx),
+                transactionSignature: signedTx.signature,
+                approvalExpirationTimeSeconds,
+            };
+            const expectedApprovalHash = hashUtils.getApprovalHashHex(
+                signedTx,
+                coordinatorContract.address,
+                txOrigin,
+                approvalExpirationTimeSeconds,
+            );
+            const approvalHash = await coordinatorContract.getCoordinatorApprovalHash.callAsync(approval);
+            expect(expectedApprovalHash).to.eq(approvalHash);
+        });
+    });
+});

contracts/coordinator/test/mixins.ts

@@ -0,0 +1,729 @@
+import {
+    addressUtils,
+    chaiSetup,
+    constants as devConstants,
+    expectContractCallFailedAsync,
+    getLatestBlockTimestampAsync,
+    provider,
+    TransactionFactory,
+    txDefaults,
+    web3Wrapper,
+} from '@0x/contracts-test-utils';
+import { BlockchainLifecycle } from '@0x/dev-utils';
+import { transactionHashUtils } from '@0x/order-utils';
+import { RevertReason, SignatureType, SignedOrder } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+import * as chai from 'chai';
+import * as ethUtil from 'ethereumjs-util';
+
+import { ApprovalFactory, artifacts, constants, CoordinatorContract, exchangeDataEncoder } from '../src';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+describe('Mixins tests', () => {
+    let transactionSignerAddress: string;
+    let approvalSignerAddress1: string;
+    let approvalSignerAddress2: string;
+    let mixins: CoordinatorContract;
+    let transactionFactory: TransactionFactory;
+    let approvalFactory1: ApprovalFactory;
+    let approvalFactory2: ApprovalFactory;
+    let defaultOrder: SignedOrder;
+    const exchangeAddress = addressUtils.generatePseudoRandomAddress();
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    before(async () => {
+        mixins = await CoordinatorContract.deployFrom0xArtifactAsync(
+            artifacts.Coordinator,
+            provider,
+            txDefaults,
+            artifacts,
+            exchangeAddress,
+        );
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        [transactionSignerAddress, approvalSignerAddress1, approvalSignerAddress2] = accounts.slice(0, 3);
+        defaultOrder = {
+            exchangeAddress: devConstants.NULL_ADDRESS,
+            makerAddress: devConstants.NULL_ADDRESS,
+            takerAddress: devConstants.NULL_ADDRESS,
+            senderAddress: mixins.address,
+            feeRecipientAddress: approvalSignerAddress1,
+            makerAssetData: devConstants.NULL_BYTES,
+            takerAssetData: devConstants.NULL_BYTES,
+            makerAssetAmount: devConstants.ZERO_AMOUNT,
+            takerAssetAmount: devConstants.ZERO_AMOUNT,
+            makerFee: devConstants.ZERO_AMOUNT,
+            takerFee: devConstants.ZERO_AMOUNT,
+            expirationTimeSeconds: devConstants.ZERO_AMOUNT,
+            salt: devConstants.ZERO_AMOUNT,
+            signature: devConstants.NULL_BYTES,
+        };
+        const transactionSignerPrivateKey =
+            devConstants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(transactionSignerAddress)];
+        const approvalSignerPrivateKey1 = devConstants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(approvalSignerAddress1)];
+        const approvalSignerPrivateKey2 = devConstants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(approvalSignerAddress2)];
+        transactionFactory = new TransactionFactory(transactionSignerPrivateKey, exchangeAddress);
+        approvalFactory1 = new ApprovalFactory(approvalSignerPrivateKey1, mixins.address);
+        approvalFactory2 = new ApprovalFactory(approvalSignerPrivateKey2, mixins.address);
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    describe('getSignerAddress', () => {
+        it('should return the correct address using the EthSign signature type', async () => {
+            const data = devConstants.NULL_BYTES;
+            const transaction = transactionFactory.newSignedTransaction(data, SignatureType.EthSign);
+            const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
+            const signerAddress = await mixins.getSignerAddress.callAsync(transactionHash, transaction.signature);
+            expect(transaction.signerAddress).to.eq(signerAddress);
+        });
+        it('should return the correct address using the EIP712 signature type', async () => {
+            const data = devConstants.NULL_BYTES;
+            const transaction = transactionFactory.newSignedTransaction(data, SignatureType.EIP712);
+            const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
+            const signerAddress = await mixins.getSignerAddress.callAsync(transactionHash, transaction.signature);
+            expect(transaction.signerAddress).to.eq(signerAddress);
+        });
+        it('should revert with with the Illegal signature type', async () => {
+            const data = devConstants.NULL_BYTES;
+            const transaction = transactionFactory.newSignedTransaction(data);
+            const illegalSignatureByte = ethUtil.toBuffer(SignatureType.Illegal).toString('hex');
+            transaction.signature = `${transaction.signature.slice(
+                0,
+                transaction.signature.length - 2,
+            )}${illegalSignatureByte}`;
+            const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
+            expectContractCallFailedAsync(
+                mixins.getSignerAddress.callAsync(transactionHash, transaction.signature),
+                RevertReason.SignatureIllegal,
+            );
+        });
+        it('should revert with with the Invalid signature type', async () => {
+            const data = devConstants.NULL_BYTES;
+            const transaction = transactionFactory.newSignedTransaction(data);
+            const invalidSignatureByte = ethUtil.toBuffer(SignatureType.Invalid).toString('hex');
+            transaction.signature = `0x${invalidSignatureByte}`;
+            const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
+            expectContractCallFailedAsync(
+                mixins.getSignerAddress.callAsync(transactionHash, transaction.signature),
+                RevertReason.SignatureInvalid,
+            );
+        });
+        it("should revert with with a signature type that doesn't exist", async () => {
+            const data = devConstants.NULL_BYTES;
+            const transaction = transactionFactory.newSignedTransaction(data);
+            const invalidSignatureByte = '04';
+            transaction.signature = `${transaction.signature.slice(
+                0,
+                transaction.signature.length - 2,
+            )}${invalidSignatureByte}`;
+            const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
+            expectContractCallFailedAsync(
+                mixins.getSignerAddress.callAsync(transactionHash, transaction.signature),
+                RevertReason.SignatureUnsupported,
+            );
+        });
+    });
+
+    describe('decodeOrdersFromFillData', () => {
+        for (const fnName of constants.SINGLE_FILL_FN_NAMES) {
+            it(`should correctly decode the orders for ${fnName} data`, async () => {
+                const orders = [defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const decodedOrders = await mixins.decodeOrdersFromFillData.callAsync(data);
+                const decodedSignedOrders = decodedOrders.map(order => ({
+                    ...order,
+                    exchangeAddress: devConstants.NULL_ADDRESS,
+                    signature: devConstants.NULL_BYTES,
+                }));
+                expect(orders).to.deep.eq(decodedSignedOrders);
+            });
+        }
+        for (const fnName of constants.BATCH_FILL_FN_NAMES) {
+            it(`should correctly decode the orders for ${fnName} data`, async () => {
+                const orders = [defaultOrder, defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const decodedOrders = await mixins.decodeOrdersFromFillData.callAsync(data);
+                const decodedSignedOrders = decodedOrders.map(order => ({
+                    ...order,
+                    exchangeAddress: devConstants.NULL_ADDRESS,
+                    signature: devConstants.NULL_BYTES,
+                }));
+                expect(orders).to.deep.eq(decodedSignedOrders);
+            });
+        }
+        for (const fnName of constants.MARKET_FILL_FN_NAMES) {
+            it(`should correctly decode the orders for ${fnName} data`, async () => {
+                const orders = [defaultOrder, defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const decodedOrders = await mixins.decodeOrdersFromFillData.callAsync(data);
+                const decodedSignedOrders = decodedOrders.map(order => ({
+                    ...order,
+                    exchangeAddress: devConstants.NULL_ADDRESS,
+                    signature: devConstants.NULL_BYTES,
+                }));
+                expect(orders).to.deep.eq(decodedSignedOrders);
+            });
+        }
+        for (const fnName of [constants.CANCEL_ORDER, constants.BATCH_CANCEL_ORDERS, constants.CANCEL_ORDERS_UP_TO]) {
+            it(`should correctly decode the orders for ${fnName} data`, async () => {
+                const orders = [defaultOrder, defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const decodedOrders = await mixins.decodeOrdersFromFillData.callAsync(data);
+                const emptyArray: any[] = [];
+                expect(emptyArray).to.deep.eq(decodedOrders);
+            });
+        }
+        it('should decode an empty array for invalid data', async () => {
+            const data = '0x0123456789';
+            const decodedOrders = await mixins.decodeOrdersFromFillData.callAsync(data);
+            const emptyArray: any[] = [];
+            expect(emptyArray).to.deep.eq(decodedOrders);
+        });
+        it('should revert if data is less than 4 bytes long', async () => {
+            const data = '0x010203';
+            await expectContractCallFailedAsync(
+                mixins.decodeOrdersFromFillData.callAsync(data),
+                RevertReason.LibBytesGreaterOrEqualTo4LengthRequired,
+            );
+        });
+    });
+
+    describe('Single order approvals', () => {
+        for (const fnName of constants.SINGLE_FILL_FN_NAMES) {
+            it(`Should be successful: function=${fnName}, caller=tx_signer, senderAddress=[verifier], approval_sig=[approver1], expiration=[valid]`, async () => {
+                const orders = [defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                await mixins.assertValidCoordinatorApprovals.callAsync(
+                    transaction,
+                    transactionSignerAddress,
+                    transaction.signature,
+                    [approvalExpirationTimeSeconds],
+                    [approval.signature],
+                    { from: transactionSignerAddress },
+                );
+            });
+            it(`Should be successful: function=${fnName}, caller=tx_signer, senderAddress=[null], approval_sig=[approver1], expiration=[valid]`, async () => {
+                const order = {
+                    ...defaultOrder,
+                    senderAddress: devConstants.NULL_ADDRESS,
+                };
+                const orders = [order];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                await mixins.assertValidCoordinatorApprovals.callAsync(
+                    transaction,
+                    transactionSignerAddress,
+                    transaction.signature,
+                    [approvalExpirationTimeSeconds],
+                    [approval.signature],
+                    { from: transactionSignerAddress },
+                );
+            });
+            it(`Should be successful: function=${fnName}, caller=approver1, senderAddress=[verifier], approval_sig=[], expiration=[]`, async () => {
+                const orders = [defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                await mixins.assertValidCoordinatorApprovals.callAsync(
+                    transaction,
+                    approvalSignerAddress1,
+                    transaction.signature,
+                    [],
+                    [],
+                    {
+                        from: approvalSignerAddress1,
+                    },
+                );
+            });
+            it(`Should be successful: function=${fnName}, caller=approver1, senderAddress=[verifier], approval_sig=[approver1], expiration=[invalid]`, async () => {
+                const orders = [defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                await mixins.assertValidCoordinatorApprovals.callAsync(
+                    transaction,
+                    approvalSignerAddress1,
+                    transaction.signature,
+                    [approvalExpirationTimeSeconds],
+                    [approval.signature],
+                    { from: approvalSignerAddress1 },
+                );
+            });
+            it(`Should be successful: function=${fnName}, caller=approver1, senderAddress=[verifier], approval_sig=[], expiration=[]`, async () => {
+                const orders = [defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                await mixins.assertValidCoordinatorApprovals.callAsync(
+                    transaction,
+                    approvalSignerAddress1,
+                    transaction.signature,
+                    [],
+                    [],
+                    {
+                        from: approvalSignerAddress1,
+                    },
+                );
+            });
+            it(`Should revert: function=${fnName}, caller=tx_signer, senderAddress=[verifier], approval_sig=[invalid], expiration=[valid]`, async () => {
+                const orders = [defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                const signature = `${approval.signature.slice(0, 4)}FFFFFFFF${approval.signature.slice(12)}`;
+                expectContractCallFailedAsync(
+                    mixins.assertValidCoordinatorApprovals.callAsync(
+                        transaction,
+                        transactionSignerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [signature],
+                        { from: transactionSignerAddress },
+                    ),
+                    RevertReason.InvalidApprovalSignature,
+                );
+            });
+            it(`Should revert: function=${fnName}, caller=tx_signer, senderAddress=[verifier], approval_sig=[approver1], expiration=[invalid]`, async () => {
+                const orders = [defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).minus(constants.TIME_BUFFER);
+                const approval = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                expectContractCallFailedAsync(
+                    mixins.assertValidCoordinatorApprovals.callAsync(
+                        transaction,
+                        transactionSignerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [approval.signature],
+                        { from: transactionSignerAddress },
+                    ),
+                    RevertReason.ApprovalExpired,
+                );
+            });
+            it(`Should revert: function=${fnName}, caller=approver2, senderAddress=[verifier], approval_sig=[approver1], expiration=[valid]`, async () => {
+                const orders = [defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                expectContractCallFailedAsync(
+                    mixins.assertValidCoordinatorApprovals.callAsync(
+                        transaction,
+                        transactionSignerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [approval.signature],
+                        { from: approvalSignerAddress2 },
+                    ),
+                    RevertReason.InvalidOrigin,
+                );
+            });
+        }
+    });
+    describe('Batch order approvals', () => {
+        for (const fnName of [
+            ...constants.BATCH_FILL_FN_NAMES,
+            ...constants.MARKET_FILL_FN_NAMES,
+            constants.MATCH_ORDERS,
+        ]) {
+            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1,approver1], approval_sig=[approver1], expiration=[valid]`, async () => {
+                const orders = [defaultOrder, defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                await mixins.assertValidCoordinatorApprovals.callAsync(
+                    transaction,
+                    transactionSignerAddress,
+                    transaction.signature,
+                    [approvalExpirationTimeSeconds],
+                    [approval.signature],
+                    { from: transactionSignerAddress },
+                );
+            });
+            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[null,null], feeRecipient=[approver1,approver1], approval_sig=[approver1], expiration=[valid]`, async () => {
+                const orders = [defaultOrder, defaultOrder].map(order => ({
+                    ...order,
+                    senderAddress: devConstants.NULL_ADDRESS,
+                }));
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                await mixins.assertValidCoordinatorApprovals.callAsync(
+                    transaction,
+                    transactionSignerAddress,
+                    transaction.signature,
+                    [approvalExpirationTimeSeconds],
+                    [approval.signature],
+                    { from: transactionSignerAddress },
+                );
+            });
+            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[null,null], feeRecipient=[approver1,approver1], approval_sig=[], expiration=[]`, async () => {
+                const orders = [defaultOrder, defaultOrder].map(order => ({
+                    ...order,
+                    senderAddress: devConstants.NULL_ADDRESS,
+                }));
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                await mixins.assertValidCoordinatorApprovals.callAsync(
+                    transaction,
+                    transactionSignerAddress,
+                    transaction.signature,
+                    [],
+                    [],
+                    { from: transactionSignerAddress },
+                );
+            });
+            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[verifier,null], feeRecipient=[approver1,approver1], approval_sig=[approver1], expiration=[valid]`, async () => {
+                const orders = [defaultOrder, { ...defaultOrder, senderAddress: devConstants.NULL_ADDRESS }];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                await mixins.assertValidCoordinatorApprovals.callAsync(
+                    transaction,
+                    transactionSignerAddress,
+                    transaction.signature,
+                    [approvalExpirationTimeSeconds],
+                    [approval.signature],
+                    { from: transactionSignerAddress },
+                );
+            });
+            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1,approver2], approval_sig=[approver1,approver2], expiration=[valid,valid]`, async () => {
+                const orders = [defaultOrder, { ...defaultOrder, feeRecipientAddress: approvalSignerAddress2 }];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval1 = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                const approval2 = approvalFactory2.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                await mixins.assertValidCoordinatorApprovals.callAsync(
+                    transaction,
+                    transactionSignerAddress,
+                    transaction.signature,
+                    [approvalExpirationTimeSeconds, approvalExpirationTimeSeconds],
+                    [approval1.signature, approval2.signature],
+                    { from: transactionSignerAddress },
+                );
+            });
+            it(`Should be successful: function=${fnName} caller=approver1, senderAddress=[verifier,verifier], feeRecipient=[approver1,approver1], approval_sig=[], expiration=[]`, async () => {
+                const orders = [defaultOrder, defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                await mixins.assertValidCoordinatorApprovals.callAsync(
+                    transaction,
+                    approvalSignerAddress1,
+                    transaction.signature,
+                    [],
+                    [],
+                    { from: approvalSignerAddress1 },
+                );
+            });
+            it(`Should revert: function=${fnName} caller=approver1, senderAddress=[verifier,verifier], feeRecipient=[approver1,approver2], approval_sig=[approver2], expiration=[valid]`, async () => {
+                const orders = [defaultOrder, { ...defaultOrder, feeRecipientAddress: approvalSignerAddress2 }];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval2 = approvalFactory2.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                expectContractCallFailedAsync(
+                    mixins.assertValidCoordinatorApprovals.callAsync(
+                        transaction,
+                        transactionSignerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [approval2.signature],
+                        { from: approvalSignerAddress1 },
+                    ),
+                    RevertReason.InvalidOrigin,
+                );
+            });
+            it(`Should revert: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver1], approval_sig=[], expiration=[]`, async () => {
+                const orders = [defaultOrder, defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                expectContractCallFailedAsync(
+                    mixins.assertValidCoordinatorApprovals.callAsync(
+                        transaction,
+                        transactionSignerAddress,
+                        transaction.signature,
+                        [],
+                        [],
+                        { from: transactionSignerAddress },
+                    ),
+                    RevertReason.InvalidApprovalSignature,
+                );
+            });
+            it(`Should revert: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver1], approval_sig=[invalid], expiration=[valid]`, async () => {
+                const orders = [defaultOrder, defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                const signature = `${approval.signature.slice(0, 4)}FFFFFFFF${approval.signature.slice(12)}`;
+                expectContractCallFailedAsync(
+                    mixins.assertValidCoordinatorApprovals.callAsync(
+                        transaction,
+                        transactionSignerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [signature],
+                        { from: transactionSignerAddress },
+                    ),
+                    RevertReason.InvalidApprovalSignature,
+                );
+            });
+            it(`Should revert: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver2], approval_sig=[valid,invalid], expiration=[valid,valid]`, async () => {
+                const orders = [defaultOrder, { ...defaultOrder, feeRecipientAddress: approvalSignerAddress2 }];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval1 = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                const approval2 = approvalFactory2.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                const approvalSignature2 = `${approval2.signature.slice(0, 4)}FFFFFFFF${approval2.signature.slice(12)}`;
+                expectContractCallFailedAsync(
+                    mixins.assertValidCoordinatorApprovals.callAsync(
+                        transaction,
+                        transactionSignerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds, approvalExpirationTimeSeconds],
+                        [approval1.signature, approvalSignature2],
+                        { from: transactionSignerAddress },
+                    ),
+                    RevertReason.InvalidApprovalSignature,
+                );
+            });
+            it(`Should revert: function=${fnName} caller=approver1, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver2], approval_sig=[invalid], expiration=[valid]`, async () => {
+                const orders = [defaultOrder, { ...defaultOrder, feeRecipientAddress: approvalSignerAddress2 }];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval2 = approvalFactory2.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                const approvalSignature2 = `${approval2.signature.slice(0, 4)}FFFFFFFF${approval2.signature.slice(12)}`;
+                expectContractCallFailedAsync(
+                    mixins.assertValidCoordinatorApprovals.callAsync(
+                        transaction,
+                        approvalSignerAddress1,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [approvalSignature2],
+                        { from: approvalSignerAddress1 },
+                    ),
+                    RevertReason.InvalidApprovalSignature,
+                );
+            });
+            it(`Should revert: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver2], approval_sig=[valid,valid], expiration=[valid,invalid]`, async () => {
+                const orders = [defaultOrder, { ...defaultOrder, feeRecipientAddress: approvalSignerAddress2 }];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds1 = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approvalExpirationTimeSeconds2 = new BigNumber(currentTimestamp).minus(constants.TIME_BUFFER);
+                const approval1 = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds1,
+                );
+                const approval2 = approvalFactory2.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds2,
+                );
+                expectContractCallFailedAsync(
+                    mixins.assertValidCoordinatorApprovals.callAsync(
+                        transaction,
+                        transactionSignerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds1, approvalExpirationTimeSeconds2],
+                        [approval1.signature, approval2.signature],
+                        { from: transactionSignerAddress },
+                    ),
+                    RevertReason.ApprovalExpired,
+                );
+            });
+            it(`Should revert: function=${fnName} caller=approver1, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver2], approval_sig=[valid], expiration=[invalid]`, async () => {
+                const orders = [defaultOrder, { ...defaultOrder, feeRecipientAddress: approvalSignerAddress2 }];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).minus(constants.TIME_BUFFER);
+                const approval2 = approvalFactory2.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                expectContractCallFailedAsync(
+                    mixins.assertValidCoordinatorApprovals.callAsync(
+                        transaction,
+                        approvalSignerAddress1,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [approval2.signature],
+                        { from: approvalSignerAddress1 },
+                    ),
+                    RevertReason.ApprovalExpired,
+                );
+            });
+            it(`Should revert: function=${fnName} caller=approver2, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver1], approval_sig=[valid], expiration=[valid]`, async () => {
+                const orders = [defaultOrder, defaultOrder];
+                const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
+                const transaction = transactionFactory.newSignedTransaction(data);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
+                const approval1 = approvalFactory1.newSignedApproval(
+                    transaction,
+                    transactionSignerAddress,
+                    approvalExpirationTimeSeconds,
+                );
+                expectContractCallFailedAsync(
+                    mixins.assertValidCoordinatorApprovals.callAsync(
+                        transaction,
+                        transactionSignerAddress,
+                        transaction.signature,
+                        [approvalExpirationTimeSeconds],
+                        [approval1.signature],
+                        { from: approvalSignerAddress2 },
+                    ),
+                    RevertReason.InvalidOrigin,
+                );
+            });
+        }
+    });
+    describe('cancels', () => {
+        it('should allow the tx signer to call `cancelOrder` without approval', async () => {
+            const orders = [defaultOrder];
+            const data = exchangeDataEncoder.encodeOrdersToExchangeData(constants.CANCEL_ORDER, orders);
+            const transaction = transactionFactory.newSignedTransaction(data);
+            await mixins.assertValidCoordinatorApprovals.callAsync(
+                transaction,
+                transactionSignerAddress,
+                transaction.signature,
+                [],
+                [],
+                { from: transactionSignerAddress },
+            );
+        });
+        it('should allow the tx signer to call `batchCancelOrders` without approval', async () => {
+            const orders = [defaultOrder, defaultOrder];
+            const data = exchangeDataEncoder.encodeOrdersToExchangeData(constants.BATCH_CANCEL_ORDERS, orders);
+            const transaction = transactionFactory.newSignedTransaction(data);
+            await mixins.assertValidCoordinatorApprovals.callAsync(
+                transaction,
+                transactionSignerAddress,
+                transaction.signature,
+                [],
+                [],
+                { from: transactionSignerAddress },
+            );
+        });
+        it('should allow the tx signer to call `cancelOrdersUpTo` without approval', async () => {
+            const orders: SignedOrder[] = [];
+            const data = exchangeDataEncoder.encodeOrdersToExchangeData(constants.CANCEL_ORDERS_UP_TO, orders);
+            const transaction = transactionFactory.newSignedTransaction(data);
+            await mixins.assertValidCoordinatorApprovals.callAsync(
+                transaction,
+                transactionSignerAddress,
+                transaction.signature,
+                [],
+                [],
+                { from: transactionSignerAddress },
+            );
+        });
+    });
+});
+// tslint:disable:max-file-line-count

contracts/coordinator/test/utils/approval_factory.ts

@@ -0,0 +1,38 @@
+import { signingUtils } from '@0x/contracts-test-utils';
+import { SignatureType, SignedZeroExTransaction } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+import * as ethUtil from 'ethereumjs-util';
+
+import { hashUtils, SignedCoordinatorApproval } from './index';
+
+export class ApprovalFactory {
+    private readonly _privateKey: Buffer;
+    private readonly _verifyingContractAddress: string;
+
+    constructor(privateKey: Buffer, verifyingContractAddress: string) {
+        this._privateKey = privateKey;
+        this._verifyingContractAddress = verifyingContractAddress;
+    }
+
+    public newSignedApproval(
+        transaction: SignedZeroExTransaction,
+        txOrigin: string,
+        approvalExpirationTimeSeconds: BigNumber,
+        signatureType: SignatureType = SignatureType.EthSign,
+    ): SignedCoordinatorApproval {
+        const approvalHashBuff = hashUtils.getApprovalHashBuffer(
+            transaction,
+            this._verifyingContractAddress,
+            txOrigin,
+            approvalExpirationTimeSeconds,
+        );
+        const signatureBuff = signingUtils.signMessage(approvalHashBuff, this._privateKey, signatureType);
+        const signedApproval = {
+            txOrigin,
+            transaction,
+            approvalExpirationTimeSeconds,
+            signature: ethUtil.addHexPrefix(signatureBuff.toString('hex')),
+        };
+        return signedApproval;
+    }
+}

contracts/coordinator/test/utils/constants.ts

@@ -0,0 +1,12 @@
+import { BigNumber } from '@0x/utils';
+
+export const constants = {
+    SINGLE_FILL_FN_NAMES: ['fillOrder', 'fillOrKillOrder', 'fillOrderNoThrow'],
+    BATCH_FILL_FN_NAMES: ['batchFillOrders', 'batchFillOrKillOrders', 'batchFillOrdersNoThrow'],
+    MARKET_FILL_FN_NAMES: ['marketBuyOrders', 'marketBuyOrdersNoThrow', 'marketSellOrders', 'marketSellOrdersNoThrow'],
+    MATCH_ORDERS: 'matchOrders',
+    CANCEL_ORDER: 'cancelOrder',
+    BATCH_CANCEL_ORDERS: 'batchCancelOrders',
+    CANCEL_ORDERS_UP_TO: 'cancelOrdersUpTo',
+    TIME_BUFFER: new BigNumber(1000),
+};

contracts/coordinator/test/utils/coordinator_registry_wrapper.ts

@@ -0,0 +1,65 @@
+import { LogDecoder, txDefaults } from '@0x/contracts-test-utils';
+import { Web3Wrapper } from '@0x/web3-wrapper';
+import { TransactionReceiptWithDecodedLogs, ZeroExProvider } from 'ethereum-types';
+
+import { artifacts, CoordinatorRegistryContract } from '../../src';
+
+export class CoordinatorRegistryWrapper {
+    private readonly _web3Wrapper: Web3Wrapper;
+    private readonly _provider: ZeroExProvider;
+    private readonly _logDecoder: LogDecoder;
+    private _coordinatorRegistryContract?: CoordinatorRegistryContract;
+    /**
+     * Instanitates an CoordinatorRegistryWrapper
+     * @param provider Web3 provider to use for all JSON RPC requests
+     * Instance of CoordinatorRegistryWrapper
+     */
+    constructor(provider: ZeroExProvider) {
+        this._web3Wrapper = new Web3Wrapper(provider);
+        this._provider = provider;
+        this._logDecoder = new LogDecoder(this._web3Wrapper, artifacts);
+    }
+    public async deployCoordinatorRegistryAsync(): Promise<CoordinatorRegistryContract> {
+        this._coordinatorRegistryContract = await CoordinatorRegistryContract.deployFrom0xArtifactAsync(
+            artifacts.CoordinatorRegistry,
+            this._provider,
+            txDefaults,
+            artifacts,
+        );
+        if (this._coordinatorRegistryContract === undefined) {
+            throw new Error(`Failed to deploy Coordinator Registry contract.`);
+        }
+        return this._coordinatorRegistryContract;
+    }
+    public async setCoordinatorEndpointAsync(
+        coordinatorOperator: string,
+        coordinatorEndpoint: string,
+    ): Promise<TransactionReceiptWithDecodedLogs> {
+        this._assertCoordinatorRegistryDeployed();
+        const txReceipt = await this._logDecoder.getTxWithDecodedLogsAsync(
+            await (this
+                ._coordinatorRegistryContract as CoordinatorRegistryContract).setCoordinatorEndpoint.sendTransactionAsync(
+                coordinatorEndpoint,
+                {
+                    from: coordinatorOperator,
+                },
+            ),
+        );
+        return txReceipt;
+    }
+    public async getCoordinatorEndpointAsync(coordinatorOperator: string): Promise<string> {
+        this._assertCoordinatorRegistryDeployed();
+        const coordinatorEndpoint = await (this
+            ._coordinatorRegistryContract as CoordinatorRegistryContract).getCoordinatorEndpoint.callAsync(
+            coordinatorOperator,
+        );
+        return coordinatorEndpoint;
+    }
+    private _assertCoordinatorRegistryDeployed(): void {
+        if (this._coordinatorRegistryContract === undefined) {
+            throw new Error(
+                'The Coordinator Registry contract was not deployed through the CoordinatorRegistryWrapper. Call `deployCoordinatorRegistryAsync` to deploy.',
+            );
+        }
+    }
+}

contracts/coordinator/test/utils/exchange_data_encoder.ts

@@ -0,0 +1,47 @@
+import { IExchangeContract } from '@0x/contracts-exchange';
+import { constants as devConstants, provider } from '@0x/contracts-test-utils';
+import { SignedOrder } from '@0x/types';
+
+import { constants } from './index';
+
+export const exchangeDataEncoder = {
+    encodeOrdersToExchangeData(fnName: string, orders: SignedOrder[]): string {
+        const exchangeInstance = new IExchangeContract(devConstants.NULL_ADDRESS, provider);
+        let data;
+        if (constants.SINGLE_FILL_FN_NAMES.indexOf(fnName) !== -1) {
+            data = (exchangeInstance as any)[fnName].getABIEncodedTransactionData(
+                orders[0],
+                orders[0].takerAssetAmount,
+                orders[0].signature,
+            );
+        } else if (constants.BATCH_FILL_FN_NAMES.indexOf(fnName) !== -1) {
+            data = (exchangeInstance as any)[fnName].getABIEncodedTransactionData(
+                orders,
+                orders.map(order => order.takerAssetAmount),
+                orders.map(order => order.signature),
+            );
+        } else if (constants.MARKET_FILL_FN_NAMES.indexOf(fnName) !== -1) {
+            data = (exchangeInstance as any)[fnName].getABIEncodedTransactionData(
+                orders,
+                orders.map(order => order.takerAssetAmount).reduce((prev, curr) => prev.plus(curr)),
+                orders.map(order => order.signature),
+            );
+        } else if (fnName === constants.MATCH_ORDERS) {
+            data = exchangeInstance.matchOrders.getABIEncodedTransactionData(
+                orders[0],
+                orders[1],
+                orders[0].signature,
+                orders[1].signature,
+            );
+        } else if (fnName === constants.CANCEL_ORDER) {
+            data = exchangeInstance.cancelOrder.getABIEncodedTransactionData(orders[0]);
+        } else if (fnName === constants.BATCH_CANCEL_ORDERS) {
+            data = exchangeInstance.batchCancelOrders.getABIEncodedTransactionData(orders);
+        } else if (fnName === constants.CANCEL_ORDERS_UP_TO) {
+            data = exchangeInstance.cancelOrdersUpTo.getABIEncodedTransactionData(devConstants.ZERO_AMOUNT);
+        } else {
+            throw new Error(`Error: ${fnName} not a supported function`);
+        }
+        return data;
+    },
+};

contracts/coordinator/test/utils/hash_utils.ts

@@ -0,0 +1,33 @@
+import { eip712Utils } from '@0x/order-utils';
+import { SignedZeroExTransaction } from '@0x/types';
+import { BigNumber, signTypedDataUtils } from '@0x/utils';
+import * as _ from 'lodash';
+
+export const hashUtils = {
+    getApprovalHashBuffer(
+        transaction: SignedZeroExTransaction,
+        verifyingContractAddress: string,
+        txOrigin: string,
+        approvalExpirationTimeSeconds: BigNumber,
+    ): Buffer {
+        const typedData = eip712Utils.createCoordinatorApprovalTypedData(
+            transaction,
+            verifyingContractAddress,
+            txOrigin,
+            approvalExpirationTimeSeconds,
+        );
+        const hashBuffer = signTypedDataUtils.generateTypedDataHash(typedData);
+        return hashBuffer;
+    },
+    getApprovalHashHex(
+        transaction: SignedZeroExTransaction,
+        verifyingContractAddress: string,
+        txOrigin: string,
+        approvalExpirationTimeSeconds: BigNumber,
+    ): string {
+        const hashHex = `0x${hashUtils
+            .getApprovalHashBuffer(transaction, verifyingContractAddress, txOrigin, approvalExpirationTimeSeconds)
+            .toString('hex')}`;
+        return hashHex;
+    },
+};

contracts/coordinator/test/utils/index.ts

@@ -0,0 +1,5 @@
+export { hashUtils } from './hash_utils';
+export { ApprovalFactory } from './approval_factory';
+export { constants } from './constants';
+export { exchangeDataEncoder } from './exchange_data_encoder';
+export * from './types';

contracts/coordinator/test/utils/types.ts

@@ -0,0 +1,12 @@
+import { SignedZeroExTransaction } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+
+export interface CoordinatorApproval {
+    transaction: SignedZeroExTransaction;
+    txOrigin: string;
+    approvalExpirationTimeSeconds: BigNumber;
+}
+
+export interface SignedCoordinatorApproval extends CoordinatorApproval {
+    signature: string;
+}

contracts/coordinator/tsconfig.json

@@ -0,0 +1,7 @@
+{
+    "extends": "../../tsconfig",
+    "compilerOptions": { "outDir": "lib", "rootDir": ".", "resolveJsonModule": true },
+    "include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*"],
+    "files": ["generated-artifacts/Coordinator.json", "generated-artifacts/CoordinatorRegistry.json"],
+    "exclude": ["./deploy/solc/solc_bin"]
+}

contracts/coordinator/tslint.json

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

contracts/dev-utils/CHANGELOG.json

@@ -0,0 +1,77 @@
+[
+    {
+        "version": "0.0.6",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564604963
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "0.0.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "0.0.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "0.0.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563006338,
+        "version": "0.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "0.0.1",
+        "changes": [
+            {
+                "note": "Create dev-utils package",
+                "pr": 1848
+            },
+            {
+                "note": "Add `LibAssetData` and `LibTransactionDecoder` contracts",
+                "pr": 1848
+            },
+            {
+                "note": "Refactor `LibAssetData` to only check 0x-specific allowances",
+                "pr": 1848
+            },
+            {
+                "note": "Refactor `LibAssetData` balance/allowance checks to never revert",
+                "pr": 1848
+            },
+            {
+                "note": "Refactor `OrderValidationUtils` to calculate `fillableTakerAssetAmount`",
+                "pr": 1848
+            },
+            {
+                "note": "Add support for StaticCallProxy",
+                "pr": 1863
+            }
+        ]
+    }
+]

contracts/dev-utils/CHANGELOG.md

@@ -0,0 +1,35 @@
+<!--
+changelogUtils.file is auto-generated using the monorepo-scripts package. Don't edit directly.
+Edit the package's CHANGELOG.json file only.
+-->
+
+CHANGELOG
+
+## v0.0.6 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v0.0.5 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v0.0.4 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v0.0.3 - _July 13, 2019_
+
+    * Dependencies updated
+
+## v0.0.2 - _July 13, 2019_
+
+    * Dependencies updated
+
+## v0.0.1 - _Invalid date_
+
+    * Create dev-utils package (#1848)
+    * Add `LibAssetData` and `LibTransactionDecoder` contracts (#1848)
+    * Refactor `LibAssetData` to only check 0x-specific allowances (#1848)
+    * Refactor `LibAssetData` balance/allowance checks to never revert (#1848)
+    * Refactor `OrderValidationUtils` to calculate `fillableTakerAssetAmount` (#1848)
+    * Add support for StaticCallProxy (#1863)

contracts/dev-utils/DEPLOYS.json

@@ -0,0 +1 @@
+[]

contracts/dev-utils/README.md

@@ -0,0 +1,73 @@
+## Dev-Utils
+
+This package implements various utilities for developers. For example, the `DevUtils` contract can query batches of balances or allowances given some `assetData`, can validate batches of orders, and can decode 0x-specific calldata. Addresses of the deployed contracts can be found in the 0x [wiki](https://0xproject.com/wiki#Deployed-Addresses) or the [DEPLOYS](./DEPLOYS.json) file within this package.
+
+## Installation
+
+**Install**
+
+```bash
+npm install @0x/contracts-dev-utils --save
+```
+
+## Bug bounty
+
+A bug bounty for the 2.0.0 contracts is ongoing! Instructions can be found [here](https://0xproject.com/wiki#Bug-Bounty).
+
+## Contributing
+
+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.
+
+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](../../CONTRIBUTING.md) before getting started.
+
+### Install Dependencies
+
+If you don't have yarn workspaces enabled (Yarn < v1.0) - enable them:
+
+```bash
+yarn config set workspaces-experimental true
+```
+
+Then install dependencies
+
+```bash
+yarn install
+```
+
+### Build
+
+To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
+
+```bash
+PKG=@0x/contracts-extensions yarn build
+```
+
+Or continuously rebuild on change:
+
+```bash
+PKG=@0x/contracts-extensions yarn watch
+```
+
+### Clean
+
+```bash
+yarn clean
+```
+
+### Lint
+
+```bash
+yarn lint
+```
+
+### Run Tests
+
+```bash
+yarn test
+```
+
+#### Testing options
+
+Contracts testing options like coverage, profiling, revert traces or backing node choosing - are described [here](../TESTING.md).

contracts/dev-utils/compiler.json

@@ -0,0 +1,32 @@
+{
+    "artifactsDir": "./generated-artifacts",
+    "contractsDir": "./contracts",
+    "useDockerisedSolc": false,
+    "isOfflineMode": false,
+    "compilerSettings": {
+        "evmVersion": "constantinople",
+        "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"
+                ]
+            }
+        }
+    },
+    "contracts": [
+        "src/DevUtils.sol",
+        "src/LibAssetData.sol",
+        "src/LibTransactionDecoder.sol",
+        "src/EthBalanceChecker.sol"
+    ]
+}

contracts/dev-utils/contracts/src/DevUtils.sol

@@ -0,0 +1,37 @@
+/*
+
+  Copyright 2018 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;
+pragma experimental ABIEncoderV2;
+
+import "./OrderValidationUtils.sol";
+import "./LibTransactionDecoder.sol";
+import "./EthBalanceChecker.sol";
+
+
+// solhint-disable no-empty-blocks
+contract DevUtils is
+    OrderValidationUtils,
+    LibTransactionDecoder,
+    EthBalanceChecker
+{
+    constructor (address _exchange, bytes memory _zrxAssetData)
+        public
+        OrderValidationUtils(_exchange, _zrxAssetData)
+    {}
+}

contracts/dev-utils/contracts/src/EthBalanceChecker.sol

@@ -0,0 +1,39 @@
+/*
+
+  Copyright 2018 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;
+
+
+contract EthBalanceChecker {
+
+    /// @dev Batch fetches ETH balances
+    /// @param addresses Array of addresses.
+    /// @return Array of ETH balances.
+    function getEthBalances(address[] memory addresses)
+        public
+        view
+        returns (uint256[] memory)
+    {
+        uint256[] memory balances = new uint256[](addresses.length);
+        for (uint256 i = 0; i != addresses.length; i++) {
+            balances[i] = addresses[i].balance;
+        }
+        return balances;
+    }
+
+}

contracts/dev-utils/contracts/src/LibAssetData.sol

@@ -0,0 +1,541 @@
+/*
+
+  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;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-utils/contracts/src/LibBytes.sol";
+import "@0x/contracts-asset-proxy/contracts/src/libs/LibAssetProxyIds.sol";
+import "@0x/contracts-exchange/contracts/src/interfaces/IExchange.sol";
+
+
+contract LibAssetData is
+    LibAssetProxyIds
+{
+    // 2^256 - 1
+    uint256 constant internal _MAX_UINT256 = uint256(-1);
+
+    // ERC20 selectors
+    bytes4 constant internal _ERC20_BALANCE_OF_SELECTOR = 0x70a08231;
+    bytes4 constant internal _ERC20_ALLOWANCE_SELECTOR = 0xdd62ed3e;
+
+    // ERC721 selectors
+    bytes4 constant internal _ERC721_OWNER_OF_SELECTOR = 0x6352211e;
+    bytes4 constant internal _ERC721_IS_APPROVED_FOR_ALL_SELECTOR = 0xe985e9c5;
+    bytes4 constant internal _ERC721_GET_APPROVED_SELECTOR = 0x081812fc;
+
+    // ERC1155 selectors
+    bytes4 constant internal _ERC1155_BALANCE_OF_SELECTOR = 0x00fdd58e;
+    bytes4 constant internal _ERC1155_IS_APPROVED_FOR_ALL_SELECTOR = 0xe985e9c5;
+
+    // `transferFrom` selector for all AssetProxy contracts
+    bytes4 constant internal _ASSET_PROXY_TRANSFER_FROM_SELECTOR = 0xa85e59e4;
+
+    using LibBytes for bytes;
+
+    // solhint-disable var-name-mixedcase
+    IExchange internal _EXCHANGE;
+    address internal _ERC20_PROXY_ADDRESS;
+    address internal _ERC721_PROXY_ADDRESS;
+    address internal _ERC1155_PROXY_ADDRESS;
+    address internal _STATIC_CALL_PROXY_ADDRESS;
+    // solhint-enable var-name-mixedcase
+
+    constructor (address _exchange)
+        public
+    {
+        _EXCHANGE = IExchange(_exchange);
+        _ERC20_PROXY_ADDRESS = _EXCHANGE.getAssetProxy(ERC20_PROXY_ID);
+        _ERC721_PROXY_ADDRESS = _EXCHANGE.getAssetProxy(ERC721_PROXY_ID);
+        _ERC1155_PROXY_ADDRESS = _EXCHANGE.getAssetProxy(ERC1155_PROXY_ID);
+        _STATIC_CALL_PROXY_ADDRESS = _EXCHANGE.getAssetProxy(STATIC_CALL_PROXY_ID);
+    }
+
+    /// @dev Returns the owner's balance of the assets(s) specified in
+    /// assetData.  When the asset data contains multiple assets (eg in
+    /// ERC1155 or Multi-Asset), the return value indicates how many
+    /// complete "baskets" of those assets are owned by owner.
+    /// @param ownerAddress Owner of the assets specified by assetData.
+    /// @param assetData Details of asset, encoded per the AssetProxy contract specification.
+    /// @return Number of assets (or asset baskets) held by owner.
+    function getBalance(address ownerAddress, bytes memory assetData)
+        public
+        view
+        returns (uint256 balance)
+    {
+        // Get id of AssetProxy contract
+        bytes4 assetProxyId = assetData.readBytes4(0);
+
+        if (assetProxyId == ERC20_PROXY_ID) {
+            // Get ERC20 token address
+            address tokenAddress = assetData.readAddress(16);
+
+            // Encode data for `balanceOf(ownerAddress)`
+            bytes memory balanceOfData = abi.encodeWithSelector(_ERC20_BALANCE_OF_SELECTOR, ownerAddress);
+
+            // Query balance
+            (bool success, bytes memory returnData) = tokenAddress.staticcall(balanceOfData);
+            balance = success && returnData.length == 32 ? returnData.readUint256(0) : 0;
+        } else if (assetProxyId == ERC721_PROXY_ID) {
+            // Get ERC721 token address and id
+            (, address tokenAddress, uint256 tokenId) = decodeERC721AssetData(assetData);
+
+            // Check if id is owned by ownerAddress
+            balance = getERC721TokenOwner(tokenAddress, tokenId) == ownerAddress ? 1 : 0;
+        } else if (assetProxyId == ERC1155_PROXY_ID) {
+            // Get ERC1155 token address, array of ids, and array of values
+            (, address tokenAddress, uint256[] memory tokenIds, uint256[] memory tokenValues,) = decodeERC1155AssetData(assetData);
+
+            uint256 length = tokenIds.length;
+            for (uint256 i = 0; i != length; i++) {
+                // Encode data for `balanceOf(ownerAddress, tokenIds[i])
+                bytes memory balanceOfData = abi.encodeWithSelector(
+                    _ERC1155_BALANCE_OF_SELECTOR,
+                    ownerAddress,
+                    tokenIds[i]
+                );
+
+                // Query balance
+                (bool success, bytes memory returnData) = tokenAddress.staticcall(balanceOfData);
+                uint256 totalBalance = success && returnData.length == 32 ? returnData.readUint256(0) : 0;
+
+                // Scale total balance down by corresponding value in assetData
+                uint256 scaledBalance = totalBalance / tokenValues[i];
+                if (scaledBalance < balance || balance == 0) {
+                    balance = scaledBalance;
+                }
+            }
+        } else if (assetProxyId == STATIC_CALL_PROXY_ID) {
+            // Encode data for `staticCallProxy.transferFrom(assetData,...)`
+            bytes memory transferFromData = abi.encodeWithSelector(
+                _ASSET_PROXY_TRANSFER_FROM_SELECTOR,
+                assetData,
+                address(0),  // `from` address is not used
+                address(0),  // `to` address is not used
+                0            // `amount` is not used
+            );
+
+            // Check if staticcall would be successful
+            (bool success,) = _STATIC_CALL_PROXY_ADDRESS.staticcall(transferFromData);
+
+            // Success means that the staticcall can be made an unlimited amount of times
+            balance = success ? _MAX_UINT256 : 0;
+        } else if (assetProxyId == MULTI_ASSET_PROXY_ID) {
+            // Get array of values and array of assetDatas
+            (, uint256[] memory assetAmounts, bytes[] memory nestedAssetData) = decodeMultiAssetData(assetData);
+
+            uint256 length = nestedAssetData.length;
+            for (uint256 i = 0; i != length; i++) {
+                // Query balance of individual assetData
+                uint256 totalBalance = getBalance(ownerAddress, nestedAssetData[i]);
+
+                // Scale total balance down by corresponding value in assetData
+                uint256 scaledBalance = totalBalance / assetAmounts[i];
+                if (scaledBalance < balance || balance == 0) {
+                    balance = scaledBalance;
+                }
+            }
+        } 
+
+        // Balance will be 0 if assetProxyId is unknown
+        return balance;
+    }
+
+    /// @dev Calls getBalance() for each element of assetData.
+    /// @param ownerAddress Owner of the assets specified by assetData.
+    /// @param assetData Array of asset details, each encoded per the AssetProxy contract specification.
+    /// @return Array of asset balances from getBalance(), with each element
+    /// corresponding to the same-indexed element in the assetData input.
+    function getBatchBalances(address ownerAddress, bytes[] memory assetData)
+        public
+        view
+        returns (uint256[] memory balances)
+    {
+        uint256 length = assetData.length;
+        balances = new uint256[](length);
+        for (uint256 i = 0; i != length; i++) {
+            balances[i] = getBalance(ownerAddress, assetData[i]);
+        }
+        return balances;
+    }
+
+    /// @dev Returns the number of asset(s) (described by assetData) that
+    /// the corresponding AssetProxy contract is authorized to spend.  When the asset data contains
+    /// multiple assets (eg for Multi-Asset), the return value indicates
+    /// how many complete "baskets" of those assets may be spent by all of the corresponding
+    /// AssetProxy contracts.
+    /// @param ownerAddress Owner of the assets specified by assetData.
+    /// @param assetData Details of asset, encoded per the AssetProxy contract specification.
+    /// @return Number of assets (or asset baskets) that the corresponding AssetProxy is authorized to spend.
+    function getAssetProxyAllowance(address ownerAddress, bytes memory assetData)
+        public
+        view
+        returns (uint256 allowance)
+    {
+        // Get id of AssetProxy contract
+        bytes4 assetProxyId = assetData.readBytes4(0);
+
+        if (assetProxyId == MULTI_ASSET_PROXY_ID) {
+            // Get array of values and array of assetDatas
+            (, uint256[] memory amounts, bytes[] memory nestedAssetData) = decodeMultiAssetData(assetData);
+
+            uint256 length = nestedAssetData.length;
+            for (uint256 i = 0; i != length; i++) {
+                // Query allowance of individual assetData
+                uint256 totalAllowance = getAssetProxyAllowance(ownerAddress, nestedAssetData[i]);
+
+                // Scale total allowance down by corresponding value in assetData
+                uint256 scaledAllowance = totalAllowance / amounts[i];
+                if (scaledAllowance < allowance || allowance == 0) {
+                    allowance = scaledAllowance;
+                }
+            }
+            return allowance;
+        }
+
+        if (assetProxyId == ERC20_PROXY_ID) {
+            // Get ERC20 token address
+            address tokenAddress = assetData.readAddress(16);
+
+            // Encode data for `allowance(ownerAddress, _ERC20_PROXY_ADDRESS)`
+            bytes memory allowanceData = abi.encodeWithSelector(
+                _ERC20_ALLOWANCE_SELECTOR,
+                ownerAddress,
+                _ERC20_PROXY_ADDRESS
+            );
+
+            // Query allowance
+            (bool success, bytes memory returnData) = tokenAddress.staticcall(allowanceData);
+            allowance = success && returnData.length == 32 ? returnData.readUint256(0) : 0;
+        } else if (assetProxyId == ERC721_PROXY_ID) {
+            // Get ERC721 token address and id
+            (, address tokenAddress, uint256 tokenId) = decodeERC721AssetData(assetData);
+
+            // Encode data for `isApprovedForAll(ownerAddress, _ERC721_PROXY_ADDRESS)`
+            bytes memory isApprovedForAllData = abi.encodeWithSelector(
+                _ERC721_IS_APPROVED_FOR_ALL_SELECTOR,
+                ownerAddress,
+                _ERC721_PROXY_ADDRESS
+            );
+
+            (bool success, bytes memory returnData) = tokenAddress.staticcall(isApprovedForAllData);
+
+            // If not approved for all, call `getApproved(tokenId)`
+            if (!success || returnData.length != 32 || returnData.readUint256(0) != 1) {
+                // Encode data for `getApproved(tokenId)`
+                bytes memory getApprovedData = abi.encodeWithSelector(_ERC721_GET_APPROVED_SELECTOR, tokenId);
+                (success, returnData) = tokenAddress.staticcall(getApprovedData);
+
+                // Allowance is 1 if successful and the approved address is the ERC721Proxy
+                allowance = success && returnData.length == 32 && returnData.readAddress(12) == _ERC721_PROXY_ADDRESS ? 1 : 0;
+            } else {
+                // Allowance is 2^256 - 1 if `isApprovedForAll` returned true
+                allowance = _MAX_UINT256;
+            }
+        } else if (assetProxyId == ERC1155_PROXY_ID) {
+            // Get ERC1155 token address
+            (, address tokenAddress, , , ) = decodeERC1155AssetData(assetData);
+
+            // Encode data for `isApprovedForAll(ownerAddress, _ERC1155_PROXY_ADDRESS)`
+            bytes memory isApprovedForAllData = abi.encodeWithSelector(
+                _ERC1155_IS_APPROVED_FOR_ALL_SELECTOR,
+                ownerAddress,
+                _ERC1155_PROXY_ADDRESS
+            );
+
+            // Query allowance
+            (bool success, bytes memory returnData) = tokenAddress.staticcall(isApprovedForAllData);
+            allowance = success && returnData.length == 32 && returnData.readUint256(0) == 1 ? _MAX_UINT256 : 0;
+        } else if (assetProxyId == STATIC_CALL_PROXY_ID) {
+            // The StaticCallProxy does not require any approvals
+            allowance = _MAX_UINT256;
+        }
+
+        // Allowance will be 0 if the assetProxyId is unknown
+        return allowance;
+    }
+
+    /// @dev Calls getAssetProxyAllowance() for each element of assetData.
+    /// @param ownerAddress Owner of the assets specified by assetData.
+    /// @param assetData Array of asset details, each encoded per the AssetProxy contract specification.
+    /// @return An array of asset allowances from getAllowance(), with each
+    /// element corresponding to the same-indexed element in the assetData input.
+    function getBatchAssetProxyAllowances(address ownerAddress, bytes[] memory assetData)
+        public
+        view
+        returns (uint256[] memory allowances)
+    {
+        uint256 length = assetData.length;
+        allowances = new uint256[](length);
+        for (uint256 i = 0; i != length; i++) {
+            allowances[i] = getAssetProxyAllowance(ownerAddress, assetData[i]);
+        }
+        return allowances;
+    }
+
+    /// @dev Calls getBalance() and getAllowance() for assetData.
+    /// @param ownerAddress Owner of the assets specified by assetData.
+    /// @param assetData Details of asset, encoded per the AssetProxy contract specification.
+    /// @return Number of assets (or asset baskets) held by owner, and number
+    /// of assets (or asset baskets) that the corresponding AssetProxy is authorized to spend.
+    function getBalanceAndAssetProxyAllowance(address ownerAddress, bytes memory assetData)
+        public
+        view
+        returns (uint256 balance, uint256 allowance)
+    {
+        balance = getBalance(ownerAddress, assetData);
+        allowance = getAssetProxyAllowance(ownerAddress, assetData);
+        return (balance, allowance);
+    }
+
+    /// @dev Calls getBatchBalances() and getBatchAllowances() for each element of assetData.
+    /// @param ownerAddress Owner of the assets specified by assetData.
+    /// @param assetData Array of asset details, each encoded per the AssetProxy contract specification.
+    /// @return An array of asset balances from getBalance(), and an array of
+    /// asset allowances from getAllowance(), with each element
+    /// corresponding to the same-indexed element in the assetData input.
+    function getBatchBalancesAndAssetProxyAllowances(address ownerAddress, bytes[] memory assetData)
+        public
+        view
+        returns (uint256[] memory balances, uint256[] memory allowances)
+    {
+        balances = getBatchBalances(ownerAddress, assetData);
+        allowances = getBatchAssetProxyAllowances(ownerAddress, assetData);
+        return (balances, allowances);
+    }
+
+    /// @dev Encode ERC-20 asset data into the format described in the AssetProxy contract specification.
+    /// @param tokenAddress The address of the ERC-20 contract hosting the asset to be traded.
+    /// @return AssetProxy-compliant data describing the asset.
+    function encodeERC20AssetData(address tokenAddress)
+        public
+        pure
+        returns (bytes memory assetData)
+    {
+        assetData = abi.encodeWithSelector(ERC20_PROXY_ID, tokenAddress);
+        return assetData;
+    }
+
+    /// @dev Decode ERC-20 asset data from the format described in the AssetProxy contract specification.
+    /// @param assetData AssetProxy-compliant asset data describing an ERC-20 asset.
+    /// @return The ERC-20 AssetProxy identifier, and the address of the ERC-20 
+    /// contract hosting this asset.
+    function decodeERC20AssetData(bytes memory assetData)
+        public
+        pure
+        returns (
+            bytes4 assetProxyId,
+            address tokenAddress
+        )
+    {
+        assetProxyId = assetData.readBytes4(0);
+
+        require(
+            assetProxyId == ERC20_PROXY_ID,
+            "WRONG_PROXY_ID"
+        );
+
+        tokenAddress = assetData.readAddress(16);
+        return (assetProxyId, tokenAddress);
+    }
+
+    /// @dev Encode ERC-721 asset data into the format described in the AssetProxy specification.
+    /// @param tokenAddress The address of the ERC-721 contract hosting the asset to be traded.
+    /// @param tokenId The identifier of the specific asset to be traded.
+    /// @return AssetProxy-compliant asset data describing the asset.
+    function encodeERC721AssetData(address tokenAddress, uint256 tokenId)
+        public
+        pure
+        returns (bytes memory assetData)
+    {
+        assetData = abi.encodeWithSelector(
+            ERC721_PROXY_ID,
+            tokenAddress,
+            tokenId
+        );
+        return assetData;
+    }
+
+    /// @dev Decode ERC-721 asset data from the format described in the AssetProxy contract specification.
+    /// @param assetData AssetProxy-compliant asset data describing an ERC-721 asset.
+    /// @return The ERC-721 AssetProxy identifier, the address of the ERC-721
+    /// contract hosting this asset, and the identifier of the specific
+    /// asset to be traded.
+    function decodeERC721AssetData(bytes memory assetData)
+        public
+        pure
+        returns (
+            bytes4 assetProxyId,
+            address tokenAddress,
+            uint256 tokenId
+        )
+    {
+        assetProxyId = assetData.readBytes4(0);
+
+        require(
+            assetProxyId == ERC721_PROXY_ID,
+            "WRONG_PROXY_ID"
+        );
+
+        tokenAddress = assetData.readAddress(16);
+        tokenId = assetData.readUint256(36);
+        return (assetProxyId, tokenAddress, tokenId);
+    }
+
+    /// @dev Encode ERC-1155 asset data into the format described in the AssetProxy contract specification.
+    /// @param tokenAddress The address of the ERC-1155 contract hosting the asset(s) to be traded.
+    /// @param tokenIds The identifiers of the specific assets to be traded.
+    /// @param tokenValues The amounts of each asset to be traded.
+    /// @param callbackData Data to be passed to receiving contracts when a transfer is performed.
+    /// @return AssetProxy-compliant asset data describing the set of assets.
+    function encodeERC1155AssetData(
+        address tokenAddress,
+        uint256[] memory tokenIds,
+        uint256[] memory tokenValues,
+        bytes memory callbackData
+    )
+        public
+        pure
+        returns (bytes memory assetData)
+    {
+        assetData = abi.encodeWithSelector(
+            ERC1155_PROXY_ID,
+            tokenAddress,
+            tokenIds,
+            tokenValues,
+            callbackData
+        );
+        return assetData;
+    }
+
+    /// @dev Decode ERC-1155 asset data from the format described in the AssetProxy contract specification.
+    /// @param assetData AssetProxy-compliant asset data describing an ERC-1155 set of assets.
+    /// @return The ERC-1155 AssetProxy identifier, the address of the ERC-1155
+    /// contract hosting the assets, an array of the identifiers of the
+    /// assets to be traded, an array of asset amounts to be traded, and
+    /// callback data.  Each element of the arrays corresponds to the
+    /// same-indexed element of the other array.  Return values specified as
+    /// `memory` are returned as pointers to locations within the memory of
+    /// the input parameter `assetData`.
+    function decodeERC1155AssetData(bytes memory assetData)
+        public
+        pure
+        returns (
+            bytes4 assetProxyId,
+            address tokenAddress,
+            uint256[] memory tokenIds,
+            uint256[] memory tokenValues,
+            bytes memory callbackData
+        )
+    {
+        assetProxyId = assetData.readBytes4(0);
+
+        require(
+            assetProxyId == ERC1155_PROXY_ID,
+            "WRONG_PROXY_ID"
+        );
+
+        assembly {
+            // Skip selector and length to get to the first parameter:
+            assetData := add(assetData, 36)
+            // Read the value of the first parameter:
+            tokenAddress := mload(assetData)
+            // Point to the next parameter's data:
+            tokenIds := add(assetData, mload(add(assetData, 32)))
+            // Point to the next parameter's data:
+            tokenValues := add(assetData, mload(add(assetData, 64)))
+            // Point to the next parameter's data:
+            callbackData := add(assetData, mload(add(assetData, 96)))
+        }
+
+        return (
+            assetProxyId,
+            tokenAddress,
+            tokenIds,
+            tokenValues,
+            callbackData
+        );
+    }
+
+    /// @dev Encode data for multiple assets, per the AssetProxy contract specification.
+    /// @param amounts The amounts of each asset to be traded.
+    /// @param nestedAssetData AssetProxy-compliant data describing each asset to be traded.
+    /// @return AssetProxy-compliant data describing the set of assets.
+    function encodeMultiAssetData(uint256[] memory amounts, bytes[] memory nestedAssetData)
+        public
+        pure
+        returns (bytes memory assetData)
+    {
+        assetData = abi.encodeWithSelector(
+            MULTI_ASSET_PROXY_ID,
+            amounts,
+            nestedAssetData
+        );
+        return assetData;
+    }
+
+    /// @dev Decode multi-asset data from the format described in the AssetProxy contract specification.
+    /// @param assetData AssetProxy-compliant data describing a multi-asset basket.
+    /// @return The Multi-Asset AssetProxy identifier, an array of the amounts
+    /// of the assets to be traded, and an array of the
+    /// AssetProxy-compliant data describing each asset to be traded.  Each
+    /// element of the arrays corresponds to the same-indexed element of the other array.
+    function decodeMultiAssetData(bytes memory assetData)
+        public
+        pure
+        returns (
+            bytes4 assetProxyId,
+            uint256[] memory amounts,
+            bytes[] memory nestedAssetData
+        )
+    {
+        assetProxyId = assetData.readBytes4(0);
+
+        require(
+            assetProxyId == MULTI_ASSET_PROXY_ID,
+            "WRONG_PROXY_ID"
+        );
+
+        // solhint-disable indent
+        (amounts, nestedAssetData) = abi.decode(
+            assetData.slice(4, assetData.length),
+            (uint256[], bytes[])
+        );
+        // solhint-enable indent
+    }
+
+    /// @dev Calls `asset.ownerOf(tokenId)`, but returns a null owner instead of reverting on an unowned asset.
+    /// @param tokenAddress Address of ERC721 asset.
+    /// @param tokenId The identifier for the specific NFT.
+    /// @return Owner of tokenId or null address if unowned.
+    function getERC721TokenOwner(address tokenAddress, uint256 tokenId)
+        public
+        view
+        returns (address ownerAddress)
+    {
+        bytes memory ownerOfCalldata = abi.encodeWithSelector(
+            _ERC721_OWNER_OF_SELECTOR,
+            tokenId
+        );
+
+        (bool success, bytes memory returnData) = tokenAddress.staticcall(ownerOfCalldata);
+
+        ownerAddress = (success && returnData.length == 32) ? returnData.readAddress(12) : address(0);
+        return ownerAddress;
+    }
+}

contracts/dev-utils/contracts/src/LibTransactionDecoder.sol

@@ -0,0 +1,193 @@
+/*
+
+  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;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-exchange-libs/contracts/src/LibExchangeSelectors.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
+import "@0x/contracts-utils/contracts/src/LibBytes.sol";
+
+
+contract LibTransactionDecoder is
+    LibExchangeSelectors
+{
+    using LibBytes for bytes;
+
+    /// @dev Decodes the call data for an Exchange contract method call.
+    /// @param transactionData ABI-encoded calldata for an Exchange
+    ///     contract method call.
+    /// @return The name of the function called, and the parameters it was
+    ///     given.  For single-order fills and cancels, the arrays will have
+    ///     just one element.
+    function decodeZeroExTransactionData(bytes memory transactionData)
+        public
+        pure
+        returns(
+            string memory functionName,
+            LibOrder.Order[] memory orders,
+            uint256[] memory takerAssetFillAmounts,
+            bytes[] memory signatures
+        )
+    {
+        bytes4 functionSelector = transactionData.readBytes4(0);
+
+        if (functionSelector == BATCH_CANCEL_ORDERS_SELECTOR) {
+            functionName = "batchCancelOrders";
+        } else if (functionSelector == BATCH_FILL_ORDERS_SELECTOR) {
+            functionName = "batchFillOrders";
+        } else if (functionSelector == BATCH_FILL_ORDERS_NO_THROW_SELECTOR) {
+            functionName = "batchFillOrdersNoThrow";
+        } else if (functionSelector == BATCH_FILL_OR_KILL_ORDERS_SELECTOR) {
+            functionName = "batchFillOrKillOrders";
+        } else if (functionSelector == CANCEL_ORDER_SELECTOR) {
+            functionName = "cancelOrder";
+        } else if (functionSelector == FILL_ORDER_SELECTOR) {
+            functionName = "fillOrder";
+        } else if (functionSelector == FILL_ORDER_NO_THROW_SELECTOR) {
+            functionName = "fillOrderNoThrow";
+        } else if (functionSelector == FILL_OR_KILL_ORDER_SELECTOR) {
+            functionName = "fillOrKillOrder";
+        } else if (functionSelector == MARKET_BUY_ORDERS_SELECTOR) {
+            functionName = "marketBuyOrders";
+        } else if (functionSelector == MARKET_BUY_ORDERS_NO_THROW_SELECTOR) {
+            functionName = "marketBuyOrdersNoThrow";
+        } else if (functionSelector == MARKET_SELL_ORDERS_SELECTOR) {
+            functionName = "marketSellOrders";
+        } else if (functionSelector == MARKET_SELL_ORDERS_NO_THROW_SELECTOR) {
+            functionName = "marketSellOrdersNoThrow";
+        } else if (functionSelector == MATCH_ORDERS_SELECTOR) {
+            functionName = "matchOrders";
+        } else if (
+            functionSelector == CANCEL_ORDERS_UP_TO_SELECTOR ||
+            functionSelector == EXECUTE_TRANSACTION_SELECTOR
+            // TODO: add new noThrow cancel functions when https://github.com/0xProject/ZEIPs/issues/35 is merged.
+        ) {
+            revert("UNIMPLEMENTED");
+        } else {
+            revert("UNKNOWN_FUNCTION_SELECTOR");
+        }
+
+        if (functionSelector == BATCH_CANCEL_ORDERS_SELECTOR) {
+            // solhint-disable-next-line indent
+            orders = abi.decode(transactionData.slice(4, transactionData.length), (LibOrder.Order[]));
+            takerAssetFillAmounts = new uint256[](0);
+            signatures = new bytes[](0);
+        } else if (
+            functionSelector == BATCH_FILL_OR_KILL_ORDERS_SELECTOR ||
+            functionSelector == BATCH_FILL_ORDERS_NO_THROW_SELECTOR ||
+            functionSelector == BATCH_FILL_ORDERS_SELECTOR
+        ) {
+            (orders, takerAssetFillAmounts, signatures) = _makeReturnValuesForBatchFill(transactionData);
+        } else if (functionSelector == CANCEL_ORDER_SELECTOR) {
+            orders = new LibOrder.Order[](1);
+            orders[0] = abi.decode(transactionData.slice(4, transactionData.length), (LibOrder.Order));
+            takerAssetFillAmounts = new uint256[](0);
+            signatures = new bytes[](0);
+        } else if (
+            functionSelector == FILL_OR_KILL_ORDER_SELECTOR ||
+            functionSelector == FILL_ORDER_SELECTOR ||
+            functionSelector == FILL_ORDER_NO_THROW_SELECTOR
+        ) {
+            (orders, takerAssetFillAmounts, signatures) = _makeReturnValuesForSingleOrderFill(transactionData);
+        } else if (
+            functionSelector == MARKET_BUY_ORDERS_SELECTOR ||
+            functionSelector == MARKET_BUY_ORDERS_NO_THROW_SELECTOR ||
+            functionSelector == MARKET_SELL_ORDERS_SELECTOR ||
+            functionSelector == MARKET_SELL_ORDERS_NO_THROW_SELECTOR
+        ) {
+            (orders, takerAssetFillAmounts, signatures) = _makeReturnValuesForMarketFill(transactionData);
+        } else if (functionSelector == MATCH_ORDERS_SELECTOR) {
+            (
+                LibOrder.Order memory leftOrder,
+                LibOrder.Order memory rightOrder,
+                bytes memory leftSignature,
+                bytes memory rightSignature
+            ) = abi.decode(
+                transactionData.slice(4, transactionData.length),
+                (LibOrder.Order, LibOrder.Order, bytes, bytes)
+            );
+
+            orders = new LibOrder.Order[](2);
+            orders[0] = leftOrder;
+            orders[1] = rightOrder;
+
+            takerAssetFillAmounts = new uint256[](2);
+            takerAssetFillAmounts[0] = leftOrder.takerAssetAmount;
+            takerAssetFillAmounts[1] = rightOrder.takerAssetAmount;
+
+            signatures = new bytes[](2);
+            signatures[0] = leftSignature;
+            signatures[1] = rightSignature;
+        }
+    }
+
+    function _makeReturnValuesForSingleOrderFill(bytes memory transactionData)
+        private
+        pure
+        returns(
+            LibOrder.Order[] memory orders,
+            uint256[] memory takerAssetFillAmounts,
+            bytes[] memory signatures
+        )
+    {
+        orders = new LibOrder.Order[](1);
+        takerAssetFillAmounts = new uint256[](1);
+        signatures = new bytes[](1);
+        // solhint-disable-next-line indent
+        (orders[0], takerAssetFillAmounts[0], signatures[0]) = abi.decode(
+            transactionData.slice(4, transactionData.length),
+            (LibOrder.Order, uint256, bytes)
+        );
+    }
+
+    function _makeReturnValuesForBatchFill(bytes memory transactionData)
+        private
+        pure
+        returns(
+            LibOrder.Order[] memory orders,
+            uint256[] memory takerAssetFillAmounts,
+            bytes[] memory signatures
+        )
+    {
+        // solhint-disable-next-line indent
+        (orders, takerAssetFillAmounts, signatures) = abi.decode(
+            transactionData.slice(4, transactionData.length),
+            // solhint-disable-next-line indent
+            (LibOrder.Order[], uint256[], bytes[])
+        );
+    }
+
+    function _makeReturnValuesForMarketFill(bytes memory transactionData)
+        private
+        pure
+        returns(
+            LibOrder.Order[] memory orders,
+            uint256[] memory takerAssetFillAmounts,
+            bytes[] memory signatures
+        )
+    {
+        takerAssetFillAmounts = new uint256[](1);
+        // solhint-disable-next-line indent
+        (orders, takerAssetFillAmounts[0], signatures) = abi.decode(
+            transactionData.slice(4, transactionData.length),
+            // solhint-disable-next-line indent
+            (LibOrder.Order[], uint256, bytes[])
+        );
+    }
+}

contracts/dev-utils/contracts/src/OrderValidationUtils.sol

@@ -0,0 +1,184 @@
+/*
+
+  Copyright 2018 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;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-exchange/contracts/src/interfaces/IExchange.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibMath.sol";
+import "@0x/contracts-utils/contracts/src/LibBytes.sol";
+import "./LibAssetData.sol";
+
+
+contract OrderValidationUtils is
+    LibAssetData,
+    LibMath
+{
+    using LibBytes for bytes;
+
+    // solhint-disable var-name-mixedcase
+    bytes internal _ZRX_ASSET_DATA;
+    // solhint-enable var-name-mixedcase
+
+    constructor (address _exchange, bytes memory _zrxAssetData)
+        public
+        LibAssetData(_exchange)
+    {
+        _ZRX_ASSET_DATA = _zrxAssetData;
+    }
+
+    /// @dev Fetches all order-relevant information needed to validate if the supplied order is fillable.
+    /// @param order The order structure.
+    /// @param signature Signature provided by maker that proves the order's authenticity.
+    /// `0x01` can always be provided if the signature does not need to be validated.
+    /// @return The orderInfo (hash, status, and `takerAssetAmount` already filled for the given order),
+    /// fillableTakerAssetAmount (amount of the order's `takerAssetAmount` that is fillable given all on-chain state),
+    /// and isValidSignature (validity of the provided signature).
+    /// NOTE: If the `takerAssetData` encodes data for multiple assets, `fillableTakerAssetAmount` will represent a "scaled"
+    /// amount, meaning it must be multiplied by all the individual asset amounts within the `takerAssetData` to get the final
+    /// amount of each asset that can be filled.
+    function getOrderRelevantState(LibOrder.Order memory order, bytes memory signature)
+        public
+        view
+        returns (
+            LibOrder.OrderInfo memory orderInfo,
+            uint256 fillableTakerAssetAmount,
+            bool isValidSignature
+        )
+    {
+        // Get info specific to order
+        orderInfo = _EXCHANGE.getOrderInfo(order);
+
+        // Validate the maker's signature
+        address makerAddress = order.makerAddress;
+        isValidSignature = _EXCHANGE.isValidSignature(
+            orderInfo.orderHash,
+            makerAddress,
+            signature
+        );
+
+        // Get the transferable amount of the `makerAsset`
+        uint256 transferableMakerAssetAmount = getTransferableAssetAmount(makerAddress, order.makerAssetData);
+
+        // Assign to stack variables to reduce redundant mloads/sloads
+        uint256 takerAssetAmount = order.takerAssetAmount;
+        uint256 makerFee = order.makerFee;
+        bytes memory zrxAssetData = _ZRX_ASSET_DATA;
+    
+        // Get the amount of `takerAsset` that is transferable to maker given the transferability of `makerAsset`, `makerFeeAsset`,
+        // and the total amounts specified in the order
+        uint256 transferableTakerAssetAmount;
+        if (order.makerAssetData.equals(zrxAssetData)) {
+            // If `makerAsset` equals `makerFeeAsset`, the % that can be filled is
+            // transferableMakerAssetAmount / (makerAssetAmount + makerFee)
+            transferableTakerAssetAmount = getPartialAmountFloor(
+                transferableMakerAssetAmount,
+                safeAdd(order.makerAssetAmount, makerFee),
+                takerAssetAmount
+            );
+        } else {
+            // Get the transferable amount of the `makerFeeAsset`
+            uint256 transferableMakerFeeAssetAmount = getTransferableAssetAmount(makerAddress, zrxAssetData);
+
+            // If `makerFee` is 0, the % that can be filled is (transferableMakerAssetAmount / makerAssetAmount)
+            if (makerFee == 0) {
+                transferableTakerAssetAmount = getPartialAmountFloor(
+                    transferableMakerAssetAmount,
+                    order.makerAssetAmount,
+                    takerAssetAmount
+                );
+
+            // If `makerAsset` does not equal `makerFeeAsset`, the % that can be filled is the lower of
+            // (transferableMakerAssetAmount / makerAssetAmount) and (transferableMakerAssetFeeAmount / makerFee)
+            } else {
+                uint256 transferableMakerToTakerAmount = getPartialAmountFloor(
+                    transferableMakerAssetAmount,
+                    order.makerAssetAmount,
+                    takerAssetAmount
+                );
+                uint256 transferableMakerFeeToTakerAmount = getPartialAmountFloor(
+                    transferableMakerFeeAssetAmount,
+                    makerFee,
+                    takerAssetAmount
+                );
+                transferableTakerAssetAmount = min256(transferableMakerToTakerAmount, transferableMakerFeeToTakerAmount);
+            }
+        }
+
+        // `fillableTakerAssetAmount` is the lower of the order's remaining `takerAssetAmount` and the `transferableTakerAssetAmount`
+        fillableTakerAssetAmount = min256(
+            safeSub(takerAssetAmount, orderInfo.orderTakerAssetFilledAmount),
+            transferableTakerAssetAmount
+        );
+
+        return (orderInfo, fillableTakerAssetAmount, isValidSignature);
+    }
+
+    /// @dev Fetches all order-relevant information needed to validate if the supplied orders are fillable.
+    /// @param orders Array of order structures.
+    /// @param signatures Array of signatures provided by makers that prove the authenticity of the orders.
+    /// `0x01` can always be provided if a signature does not need to be validated.
+    /// @return The ordersInfo (array of the hash, status, and `takerAssetAmount` already filled for each order),
+    /// fillableTakerAssetAmounts (array of amounts for each order's `takerAssetAmount` that is fillable given all on-chain state),
+    /// and isValidSignature (array containing the validity of each provided signature).
+    /// NOTE: If the `takerAssetData` encodes data for multiple assets, each element of `fillableTakerAssetAmounts`
+    /// will represent a "scaled" amount, meaning it must be multiplied by all the individual asset amounts within
+    /// the `takerAssetData` to get the final amount of each asset that can be filled.
+    function getOrderRelevantStates(LibOrder.Order[] memory orders, bytes[] memory signatures)
+        public
+        view
+        returns (
+            LibOrder.OrderInfo[] memory ordersInfo,
+            uint256[] memory fillableTakerAssetAmounts,
+            bool[] memory isValidSignature
+        )
+    {
+        uint256 length = orders.length;
+        ordersInfo = new LibOrder.OrderInfo[](length);
+        fillableTakerAssetAmounts = new uint256[](length);
+        isValidSignature = new bool[](length);
+
+        for (uint256 i = 0; i != length; i++) {
+            (ordersInfo[i], fillableTakerAssetAmounts[i], isValidSignature[i]) = getOrderRelevantState(
+                orders[i],
+                signatures[i]
+            );
+        }
+
+        return (ordersInfo, fillableTakerAssetAmounts, isValidSignature);
+    }
+
+    /// @dev Gets the amount of an asset transferable by the owner.
+    /// @param ownerAddress Address of the owner of the asset.
+    /// @param assetData Description of tokens, per the AssetProxy contract specification.
+    /// @return The amount of the asset tranferable by the owner.
+    /// NOTE: If the `assetData` encodes data for multiple assets, the `transferableAssetAmount`
+    /// will represent the amount of times the entire `assetData` can be transferred. To calculate
+    /// the total individual transferable amounts, this scaled `transferableAmount` must be multiplied by 
+    /// the individual asset amounts located within the `assetData`.
+    function getTransferableAssetAmount(address ownerAddress, bytes memory assetData)
+        public
+        view
+        returns (uint256 transferableAssetAmount)
+    {
+        (uint256 balance, uint256 allowance) = getBalanceAndAssetProxyAllowance(ownerAddress, assetData);
+        transferableAssetAmount = min256(balance, allowance);
+        return transferableAssetAmount;
+    }
+}

contracts/dev-utils/package.json

@@ -0,0 +1,92 @@
+{
+    "name": "@0x/contracts-dev-utils",
+    "version": "0.0.6",
+    "engines": {
+        "node": ">=6.12"
+    },
+    "description": "0x protocol specific utility contracts",
+    "main": "lib/src/index.js",
+    "directories": {
+        "test": "test"
+    },
+    "scripts": {
+        "build": "yarn pre_build && tsc -b",
+        "build:ci": "yarn build",
+        "pre_build": "run-s compile generate_contract_wrappers",
+        "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 generated-artifacts generated-wrappers",
+        "generate_contract_wrappers": "abi-gen --abis  ${npm_package_config_abis} --template ../../node_modules/@0x/abi-gen-templates/contract.handlebars --partials '../../node_modules/@0x/abi-gen-templates/partials/**/*.handlebars' --output generated-wrappers --backend ethers",
+        "lint": "tslint --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
+        "fix": "tslint --fix --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
+        "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",
+        "lint-contracts": "solhint -c ../.solhint.json contracts/**/**/**/**/*.sol"
+    },
+    "config": {
+        "abis": "./generated-artifacts/@(DevUtils|LibAssetData|LibTransactionDecoder|EthBalanceChecker).json",
+        "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually."
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/0xProject/0x-monorepo.git"
+    },
+    "license": "Apache-2.0",
+    "bugs": {
+        "url": "https://github.com/0xProject/0x-monorepo/issues"
+    },
+    "homepage": "https://github.com/0xProject/0x-monorepo/contracts/dev-utils/README.md",
+    "devDependencies": {
+        "@0x/abi-gen": "^3.1.2",
+        "@0x/contract-wrappers": "^10.1.0",
+        "@0x/contracts-gen": "^1.0.12",
+        "@0x/contracts-test-utils": "^3.1.12",
+        "@0x/dev-utils": "^2.2.6",
+        "@0x/sol-compiler": "^3.1.11",
+        "@0x/tslint-config": "^3.0.1",
+        "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
+        "@types/node": "*",
+        "chai": "^4.0.1",
+        "chai-as-promised": "^7.1.0",
+        "chai-bignumber": "^3.0.0",
+        "dirty-chai": "^2.0.1",
+        "make-promises-safe": "^1.1.0",
+        "mocha": "^6.2.0",
+        "npm-run-all": "^4.1.2",
+        "shx": "^0.2.2",
+        "solhint": "^1.4.1",
+        "tslint": "5.11.0",
+        "typescript": "3.0.1"
+    },
+    "dependencies": {
+        "@0x/base-contract": "^5.3.0",
+        "@0x/contracts-asset-proxy": "^2.2.4",
+        "@0x/contracts-erc1155": "^1.1.11",
+        "@0x/contracts-erc20": "^2.2.10",
+        "@0x/contracts-erc721": "^2.1.11",
+        "@0x/contracts-exchange": "^2.1.10",
+        "@0x/contracts-exchange-libs": "^3.0.4",
+        "@0x/contracts-utils": "^3.2.0",
+        "@0x/order-utils": "^8.2.4",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.4.2",
+        "@0x/web3-wrapper": "^6.0.9",
+        "ethereum-types": "^2.1.4",
+        "ethereumjs-util": "^5.1.1"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

contracts/dev-utils/src/artifacts.ts

@@ -0,0 +1,15 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+import { ContractArtifact } from 'ethereum-types';
+
+import * as DevUtils from '../generated-artifacts/DevUtils.json';
+import * as LibAssetData from '../generated-artifacts/LibAssetData.json';
+import * as LibTransactionDecoder from '../generated-artifacts/LibTransactionDecoder.json';
+export const artifacts = {
+    DevUtils: DevUtils as ContractArtifact,
+    LibTransactionDecoder: LibTransactionDecoder as ContractArtifact,
+    LibAssetData: LibAssetData as ContractArtifact,
+};

contracts/dev-utils/src/index.ts

@@ -0,0 +1,2 @@
+export * from './artifacts';
+export * from './wrappers';

contracts/dev-utils/src/wrappers.ts

@@ -0,0 +1,8 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+export * from '../generated-wrappers/dev_utils';
+export * from '../generated-wrappers/lib_asset_data';
+export * from '../generated-wrappers/lib_transaction_decoder';

contracts/dev-utils/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/dev-utils/test/lib_asset_data.ts

@@ -0,0 +1,538 @@
+import * as chai from 'chai';
+import { LogWithDecodedArgs } from 'ethereum-types';
+
+import {
+    artifacts as proxyArtifacts,
+    ERC1155ProxyContract,
+    ERC20ProxyContract,
+    ERC721ProxyContract,
+    MultiAssetProxyContract,
+    StaticCallProxyContract,
+    TestStaticCallTargetContract,
+} from '@0x/contracts-asset-proxy';
+import {
+    artifacts as erc1155Artifacts,
+    ERC1155MintableContract,
+    ERC1155TransferSingleEventArgs,
+} from '@0x/contracts-erc1155';
+import { artifacts as erc20Artifacts, DummyERC20TokenContract } from '@0x/contracts-erc20';
+import { artifacts as erc721Artifacts, DummyERC721TokenContract } from '@0x/contracts-erc721';
+import { artifacts as exchangeArtifacts, ExchangeContract } from '@0x/contracts-exchange';
+import { chaiSetup, constants, LogDecoder, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
+import { BlockchainLifecycle } from '@0x/dev-utils';
+import { assetDataUtils } from '@0x/order-utils';
+import { AssetProxyId } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+import * as ethUtil from 'ethereumjs-util';
+
+import { artifacts, LibAssetDataContract } from '../src';
+
+chaiSetup.configure();
+const expect = chai.expect;
+
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+const KNOWN_ERC20_ENCODING = {
+    address: '0x1dc4c1cefef38a777b15aa20260a54e584b16c48',
+    assetData: '0xf47261b00000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c48',
+};
+const KNOWN_ERC721_ENCODING = {
+    address: '0x1dc4c1cefef38a777b15aa20260a54e584b16c48',
+    tokenId: new BigNumber(1),
+    assetData:
+        '0x025717920000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c480000000000000000000000000000000000000000000000000000000000000001',
+};
+const KNOWN_ERC1155_ENCODING = {
+    tokenAddress: '0x1dc4c1cefef38a777b15aa20260a54e584b16c48',
+    tokenIds: [new BigNumber(100), new BigNumber(1001), new BigNumber(10001)],
+    tokenValues: [new BigNumber(200), new BigNumber(2001), new BigNumber(20001)],
+    callbackData:
+        '0x025717920000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c480000000000000000000000000000000000000000000000000000000000000001',
+    assetData:
+        '0xa7cb5fb70000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c480000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006400000000000000000000000000000000000000000000000000000000000003e90000000000000000000000000000000000000000000000000000000000002711000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000c800000000000000000000000000000000000000000000000000000000000007d10000000000000000000000000000000000000000000000000000000000004e210000000000000000000000000000000000000000000000000000000000000044025717920000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c48000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000',
+};
+const KNOWN_MULTI_ASSET_ENCODING = {
+    amounts: [new BigNumber(70), new BigNumber(1), new BigNumber(18)],
+    nestedAssetData: [
+        KNOWN_ERC20_ENCODING.assetData,
+        KNOWN_ERC721_ENCODING.assetData,
+        KNOWN_ERC1155_ENCODING.assetData,
+    ],
+    assetData:
+        '0x94cfcdd7000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000046000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000024f47261b00000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c48000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044025717920000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c480000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000204a7cb5fb70000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c480000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006400000000000000000000000000000000000000000000000000000000000003e90000000000000000000000000000000000000000000000000000000000002711000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000c800000000000000000000000000000000000000000000000000000000000007d10000000000000000000000000000000000000000000000000000000000004e210000000000000000000000000000000000000000000000000000000000000044025717920000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c4800000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+};
+
+describe('LibAssetData', () => {
+    let exchange: ExchangeContract;
+    let erc20Proxy: ERC20ProxyContract;
+    let erc721Proxy: ERC721ProxyContract;
+    let erc1155Proxy: ERC1155ProxyContract;
+    let multiAssetProxy: MultiAssetProxyContract;
+    let staticCallProxy: StaticCallProxyContract;
+    let staticCallTarget: TestStaticCallTargetContract;
+    let libAssetData: LibAssetDataContract;
+
+    let tokenOwnerAddress: string;
+
+    let erc20Token: DummyERC20TokenContract;
+    let erc721Token: DummyERC721TokenContract;
+    let erc1155Token: ERC1155MintableContract;
+
+    const erc20TokenTotalSupply = new BigNumber(1);
+
+    const firstERC721TokenId = new BigNumber(1);
+    const numberOfERC721Tokens = 10;
+
+    let erc1155TokenId: BigNumber;
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+
+        exchange = await ExchangeContract.deployFrom0xArtifactAsync(
+            exchangeArtifacts.Exchange,
+            provider,
+            txDefaults,
+            artifacts,
+            constants.NULL_BYTES,
+        );
+
+        erc20Proxy = await ERC20ProxyContract.deployFrom0xArtifactAsync(
+            proxyArtifacts.ERC20Proxy,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+        erc721Proxy = await ERC721ProxyContract.deployFrom0xArtifactAsync(
+            proxyArtifacts.ERC721Proxy,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+        erc1155Proxy = await ERC1155ProxyContract.deployFrom0xArtifactAsync(
+            proxyArtifacts.ERC1155Proxy,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+        multiAssetProxy = await MultiAssetProxyContract.deployFrom0xArtifactAsync(
+            proxyArtifacts.MultiAssetProxy,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+        staticCallProxy = await StaticCallProxyContract.deployFrom0xArtifactAsync(
+            proxyArtifacts.StaticCallProxy,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+
+        await exchange.registerAssetProxy.awaitTransactionSuccessAsync(erc20Proxy.address);
+        await exchange.registerAssetProxy.awaitTransactionSuccessAsync(erc721Proxy.address);
+        await exchange.registerAssetProxy.awaitTransactionSuccessAsync(erc1155Proxy.address);
+        await exchange.registerAssetProxy.awaitTransactionSuccessAsync(multiAssetProxy.address);
+        await exchange.registerAssetProxy.awaitTransactionSuccessAsync(staticCallProxy.address);
+
+        libAssetData = await LibAssetDataContract.deployFrom0xArtifactAsync(
+            artifacts.LibAssetData,
+            provider,
+            txDefaults,
+            artifacts,
+            exchange.address,
+        );
+
+        staticCallTarget = await TestStaticCallTargetContract.deployFrom0xArtifactAsync(
+            proxyArtifacts.TestStaticCallTarget,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+
+        [tokenOwnerAddress] = await web3Wrapper.getAvailableAddressesAsync();
+
+        erc20Token = await DummyERC20TokenContract.deployFrom0xArtifactAsync(
+            erc20Artifacts.DummyERC20Token,
+            provider,
+            txDefaults,
+            artifacts,
+            'Dummy',
+            'DUM',
+            new BigNumber(1),
+            erc20TokenTotalSupply,
+        );
+
+        erc721Token = await DummyERC721TokenContract.deployFrom0xArtifactAsync(
+            erc721Artifacts.DummyERC721Token,
+            provider,
+            txDefaults,
+            artifacts,
+            'Dummy',
+            'DUM',
+        );
+        // mint `numberOfERC721Tokens` tokens
+        const transactionMinedPromises = [];
+        for (let i = 0; i < numberOfERC721Tokens; i++) {
+            transactionMinedPromises.push(
+                erc721Token.mint.awaitTransactionSuccessAsync(tokenOwnerAddress, firstERC721TokenId.plus(i - 1)),
+            );
+        }
+        await Promise.all(transactionMinedPromises);
+
+        erc1155Token = await ERC1155MintableContract.deployFrom0xArtifactAsync(
+            erc1155Artifacts.ERC1155Mintable,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+
+        const logDecoder = new LogDecoder(web3Wrapper, erc1155Artifacts);
+        const transactionReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+            await erc1155Token.create.sendTransactionAsync('uri:Dummy', /*isNonFungible:*/ false),
+        );
+
+        // tslint:disable-next-line no-unnecessary-type-assertion
+        erc1155TokenId = (transactionReceipt.logs[0] as LogWithDecodedArgs<ERC1155TransferSingleEventArgs>).args.id;
+        await erc1155Token.mintFungible.awaitTransactionSuccessAsync(
+            erc1155TokenId,
+            [tokenOwnerAddress],
+            [new BigNumber(1)],
+        );
+    });
+
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    it('should have a deployed-to address', () => {
+        expect(libAssetData.address.slice(0, 2)).to.equal('0x');
+    });
+
+    describe('encoding and decoding', () => {
+        it('should encode ERC20 asset data', async () => {
+            expect(await libAssetData.encodeERC20AssetData.callAsync(KNOWN_ERC20_ENCODING.address)).to.equal(
+                KNOWN_ERC20_ENCODING.assetData,
+            );
+        });
+
+        it('should decode ERC20 asset data', async () => {
+            expect(await libAssetData.decodeERC20AssetData.callAsync(KNOWN_ERC20_ENCODING.assetData)).to.deep.equal([
+                AssetProxyId.ERC20,
+                KNOWN_ERC20_ENCODING.address,
+            ]);
+        });
+
+        it('should encode ERC721 asset data', async () => {
+            expect(
+                await libAssetData.encodeERC721AssetData.callAsync(
+                    KNOWN_ERC721_ENCODING.address,
+                    KNOWN_ERC721_ENCODING.tokenId,
+                ),
+            ).to.equal(KNOWN_ERC721_ENCODING.assetData);
+        });
+
+        it('should decode ERC721 asset data', async () => {
+            expect(await libAssetData.decodeERC721AssetData.callAsync(KNOWN_ERC721_ENCODING.assetData)).to.deep.equal([
+                AssetProxyId.ERC721,
+                KNOWN_ERC721_ENCODING.address,
+                KNOWN_ERC721_ENCODING.tokenId,
+            ]);
+        });
+
+        it('should encode ERC1155 asset data', async () => {
+            expect(
+                await libAssetData.encodeERC1155AssetData.callAsync(
+                    KNOWN_ERC1155_ENCODING.tokenAddress,
+                    KNOWN_ERC1155_ENCODING.tokenIds,
+                    KNOWN_ERC1155_ENCODING.tokenValues,
+                    KNOWN_ERC1155_ENCODING.callbackData,
+                ),
+            ).to.equal(KNOWN_ERC1155_ENCODING.assetData);
+        });
+
+        it('should decode ERC1155 asset data', async () => {
+            expect(await libAssetData.decodeERC1155AssetData.callAsync(KNOWN_ERC1155_ENCODING.assetData)).to.deep.equal(
+                [
+                    AssetProxyId.ERC1155,
+                    KNOWN_ERC1155_ENCODING.tokenAddress,
+                    KNOWN_ERC1155_ENCODING.tokenIds,
+                    KNOWN_ERC1155_ENCODING.tokenValues,
+                    KNOWN_ERC1155_ENCODING.callbackData,
+                ],
+            );
+        });
+
+        it('should encode multiasset data', async () => {
+            expect(
+                await libAssetData.encodeMultiAssetData.callAsync(
+                    KNOWN_MULTI_ASSET_ENCODING.amounts,
+                    KNOWN_MULTI_ASSET_ENCODING.nestedAssetData,
+                ),
+            ).to.equal(KNOWN_MULTI_ASSET_ENCODING.assetData);
+        });
+
+        it('should decode multiasset data', async () => {
+            expect(
+                await libAssetData.decodeMultiAssetData.callAsync(KNOWN_MULTI_ASSET_ENCODING.assetData),
+            ).to.deep.equal([
+                AssetProxyId.MultiAsset,
+                KNOWN_MULTI_ASSET_ENCODING.amounts,
+                KNOWN_MULTI_ASSET_ENCODING.nestedAssetData,
+            ]);
+        });
+    });
+
+    describe('getBalance', () => {
+        it('should query ERC20 balance by asset data', async () => {
+            const assetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
+            expect(await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData)).to.bignumber.equal(
+                erc20TokenTotalSupply,
+            );
+        });
+
+        it('should return 0 if ERC20 token does not exist', async () => {
+            const assetData = assetDataUtils.encodeERC20AssetData(constants.NULL_ADDRESS);
+            const balance = await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData);
+            expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+
+        it('should query ERC721 balance by asset data', async () => {
+            const assetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId);
+            expect(await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData)).to.bignumber.equal(1);
+        });
+
+        it('should return 0 if ERC721 token does not exist', async () => {
+            const assetData = assetDataUtils.encodeERC721AssetData(constants.NULL_ADDRESS, firstERC721TokenId);
+            const balance = await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData);
+            expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+
+        it('should query ERC1155 balances by asset data', async () => {
+            const assetData = assetDataUtils.encodeERC1155AssetData(
+                erc1155Token.address,
+                [erc1155TokenId],
+                [new BigNumber(1)],
+                constants.NULL_BYTES,
+            );
+            expect(await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData)).to.bignumber.equal(1);
+        });
+
+        it('should return 0 if ERC1155 token does not exist', async () => {
+            const assetData = assetDataUtils.encodeERC1155AssetData(
+                constants.NULL_ADDRESS,
+                [erc1155TokenId],
+                [new BigNumber(1)],
+                constants.NULL_BYTES,
+            );
+            const balance = await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData);
+            expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+
+        it('should query multi-asset batch balance by asset data', async () => {
+            const assetData = assetDataUtils.encodeMultiAssetData(
+                [new BigNumber(1), new BigNumber(1)],
+                [
+                    assetDataUtils.encodeERC20AssetData(erc20Token.address),
+                    assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId),
+                ],
+            );
+            expect(await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData)).to.bignumber.equal(
+                Math.min(erc20TokenTotalSupply.toNumber(), numberOfERC721Tokens),
+            );
+        });
+
+        it('should return a balance of 0 if the assetData does not correspond to an AssetProxy contract', async () => {
+            const fakeAssetData = '0x01020304';
+            const balance = await libAssetData.getBalance.callAsync(tokenOwnerAddress, fakeAssetData);
+            expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+
+        it('should return a balance of MAX_UINT256 if the the StaticCallProxy assetData contains data for a successful staticcall', async () => {
+            const staticCallData = staticCallTarget.isOddNumber.getABIEncodedTransactionData(new BigNumber(1));
+            const trueAsBuffer = ethUtil.toBuffer('0x0000000000000000000000000000000000000000000000000000000000000001');
+            const expectedResultHash = ethUtil.bufferToHex(ethUtil.sha3(trueAsBuffer));
+            const assetData = assetDataUtils.encodeStaticCallAssetData(
+                staticCallTarget.address,
+                staticCallData,
+                expectedResultHash,
+            );
+            const balance = await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData);
+            expect(balance).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+        });
+
+        it('should return a balance of 0 if the the StaticCallProxy assetData contains data for an unsuccessful staticcall', async () => {
+            const staticCallData = staticCallTarget.isOddNumber.getABIEncodedTransactionData(new BigNumber(0));
+            const trueAsBuffer = ethUtil.toBuffer('0x0000000000000000000000000000000000000000000000000000000000000001');
+            const expectedResultHash = ethUtil.bufferToHex(ethUtil.sha3(trueAsBuffer));
+            const assetData = assetDataUtils.encodeStaticCallAssetData(
+                staticCallTarget.address,
+                staticCallData,
+                expectedResultHash,
+            );
+            const balance = await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData);
+            expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+    });
+
+    describe('getAssetProxyAllowance', () => {
+        it('should query ERC20 allowances by asset data', async () => {
+            const allowance = new BigNumber(1);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
+                from: tokenOwnerAddress,
+            });
+            const assetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
+            expect(
+                await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData),
+            ).to.bignumber.equal(allowance);
+        });
+
+        it('should query ERC721 approval by asset data', async () => {
+            await erc721Token.approve.awaitTransactionSuccessAsync(erc721Proxy.address, firstERC721TokenId, {
+                from: tokenOwnerAddress,
+            });
+            const assetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId);
+            expect(
+                await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData),
+            ).to.bignumber.equal(1);
+        });
+
+        it('should query ERC721 approvalForAll by assetData', async () => {
+            await erc721Token.setApprovalForAll.awaitTransactionSuccessAsync(erc721Proxy.address, true, {
+                from: tokenOwnerAddress,
+            });
+            const assetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId);
+            expect(
+                await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData),
+            ).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+        });
+
+        it('should query ERC1155 allowances by asset data', async () => {
+            await erc1155Token.setApprovalForAll.awaitTransactionSuccessAsync(erc1155Proxy.address, true, {
+                from: tokenOwnerAddress,
+            });
+            const assetData = assetDataUtils.encodeERC1155AssetData(
+                erc1155Token.address,
+                [erc1155TokenId],
+                [new BigNumber(1)],
+                constants.NULL_BYTES,
+            );
+            expect(
+                await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData),
+            ).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+        });
+
+        it('should query multi-asset allowances by asset data', async () => {
+            const allowance = new BigNumber(1);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
+                from: tokenOwnerAddress,
+            });
+            await erc721Token.approve.awaitTransactionSuccessAsync(erc721Proxy.address, firstERC721TokenId, {
+                from: tokenOwnerAddress,
+            });
+            const assetData = assetDataUtils.encodeMultiAssetData(
+                [new BigNumber(1), new BigNumber(1)],
+                [
+                    assetDataUtils.encodeERC20AssetData(erc20Token.address),
+                    assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId),
+                ],
+            );
+            expect(
+                await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData),
+            ).to.bignumber.equal(1);
+            return;
+        });
+
+        it('should return an allowance of 0 if the assetData does not correspond to an AssetProxy contract', async () => {
+            const fakeAssetData = '0x01020304';
+            const allowance = await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, fakeAssetData);
+            expect(allowance).to.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+
+        it('should return an allowance of MAX_UINT256 for any staticCallAssetData', async () => {
+            const staticCallData = AssetProxyId.StaticCall;
+            const assetData = assetDataUtils.encodeStaticCallAssetData(
+                staticCallTarget.address,
+                staticCallData,
+                constants.KECCAK256_NULL,
+            );
+            const allowance = await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData);
+            expect(allowance).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+        });
+    });
+
+    describe('getBatchBalances', () => {
+        it('should query balances for a batch of asset data strings', async () => {
+            const erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
+            const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId);
+            expect(
+                await libAssetData.getBatchBalances.callAsync(tokenOwnerAddress, [erc20AssetData, erc721AssetData]),
+            ).to.deep.equal([new BigNumber(erc20TokenTotalSupply), new BigNumber(1)]);
+        });
+    });
+
+    describe('getERC721TokenOwner', async () => {
+        it('should return the null address when tokenId is not owned', async () => {
+            const nonexistentTokenId = new BigNumber(1234567890);
+            expect(
+                await libAssetData.getERC721TokenOwner.callAsync(erc721Token.address, nonexistentTokenId),
+            ).to.be.equal(constants.NULL_ADDRESS);
+        });
+        it('should return the owner address when tokenId is owned', async () => {
+            expect(
+                await libAssetData.getERC721TokenOwner.callAsync(erc721Token.address, firstERC721TokenId),
+            ).to.be.equal(tokenOwnerAddress);
+        });
+    });
+
+    describe('getBalanceAndAllowance', () => {
+        it('should query balance and allowance together, from asset data', async () => {
+            const allowance = new BigNumber(1);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
+                from: tokenOwnerAddress,
+            });
+            const assetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
+            expect(
+                await libAssetData.getBalanceAndAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData),
+            ).to.deep.equal([new BigNumber(erc20TokenTotalSupply), allowance]);
+        });
+    });
+    describe('getBatchBalancesAndAllowances', () => {
+        it('should query balances and allowances together, from an asset data array', async () => {
+            const allowance = new BigNumber(1);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
+                from: tokenOwnerAddress,
+            });
+            const assetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
+            expect(
+                await libAssetData.getBatchBalancesAndAssetProxyAllowances.callAsync(tokenOwnerAddress, [assetData]),
+            ).to.deep.equal([[new BigNumber(erc20TokenTotalSupply)], [allowance]]);
+        });
+    });
+
+    describe('getBatchAssetProxyAllowances', () => {
+        it('should query allowances for a batch of asset data strings', async () => {
+            const allowance = new BigNumber(1);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
+                from: tokenOwnerAddress,
+            });
+            await erc721Token.approve.awaitTransactionSuccessAsync(erc721Proxy.address, firstERC721TokenId, {
+                from: tokenOwnerAddress,
+            });
+            const erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
+            const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId);
+            expect(
+                await libAssetData.getBatchAssetProxyAllowances.callAsync(tokenOwnerAddress, [
+                    erc20AssetData,
+                    erc721AssetData,
+                ]),
+            ).to.deep.equal([new BigNumber(1), new BigNumber(1)]);
+        });
+    });
+});
+// tslint:disable:max-file-line-count

contracts/dev-utils/test/lib_transaction_decoder.ts

@@ -0,0 +1,140 @@
+import { IExchangeContract } from '@0x/contracts-exchange';
+import { chaiSetup, constants, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
+import { BlockchainLifecycle } from '@0x/dev-utils';
+import { BigNumber } from '@0x/utils';
+import * as chai from 'chai';
+
+import { artifacts, LibTransactionDecoderContract } from '../src';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+const order = {
+    makerAddress: '0xe36ea790bc9d7ab70c55260c66d52b1eca985f84',
+    takerAddress: '0x0000000000000000000000000000000000000000',
+    feeRecipientAddress: '0x78dc5d2d739606d31509c31d654056a45185ecb6',
+    senderAddress: '0x6ecbe1db9ef729cbe972c83fb886247691fb6beb',
+    makerAssetAmount: new BigNumber('100000000000000000000'),
+    takerAssetAmount: new BigNumber('200000000000000000000'),
+    makerFee: new BigNumber('1000000000000000000'),
+    takerFee: new BigNumber('1000000000000000000'),
+    expirationTimeSeconds: new BigNumber('1552396423'),
+    salt: new BigNumber('66097384406870180066678463045003379626790660770396923976862707230261946348951'),
+    makerAssetData: '0xf47261b000000000000000000000000034d402f14d58e001d8efbe6585051bf9706aa064',
+    takerAssetData: '0xf47261b000000000000000000000000025b8fe1de9daf8ba351890744ff28cf7dfa8f5e3',
+};
+const takerAssetFillAmount = new BigNumber('100000000000000000000');
+const signature =
+    '0x1ce8e3c600d933423172b5021158a6be2e818613ff8e762d70ef490c752fd98a626a215f09f169668990414de75a53da221c294a3002f796d004827258b641876e03';
+
+describe('LibTransactionDecoder', () => {
+    let libTxDecoder: LibTransactionDecoderContract;
+    const exchangeInterface = new IExchangeContract(constants.NULL_ADDRESS, provider, txDefaults);
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+        libTxDecoder = await LibTransactionDecoderContract.deployFrom0xArtifactAsync(
+            artifacts.LibTransactionDecoder,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    it('should decode an Exchange.batchCancelOrders() transaction', async () => {
+        const input = exchangeInterface.batchCancelOrders.getABIEncodedTransactionData([order, order]);
+        expect(await libTxDecoder.decodeZeroExTransactionData.callAsync(input)).to.deep.equal([
+            'batchCancelOrders',
+            [order, order],
+            [],
+            [],
+        ]);
+    });
+
+    for (const func of ['batchFillOrders', 'batchFillOrdersNoThrow', 'batchFillOrKillOrders']) {
+        const input = (exchangeInterface as any)[func].getABIEncodedTransactionData(
+            [order, order],
+            [takerAssetFillAmount, takerAssetFillAmount],
+            [signature, signature],
+        );
+        it(`should decode an Exchange.${func}() transaction`, async () => {
+            expect(await libTxDecoder.decodeZeroExTransactionData.callAsync(input)).to.deep.equal([
+                func,
+                [order, order],
+                [takerAssetFillAmount, takerAssetFillAmount],
+                [signature, signature],
+            ]);
+        });
+    }
+
+    it('should decode an Exchange.cancelOrder() transaction', async () => {
+        const input = exchangeInterface.cancelOrder.getABIEncodedTransactionData(order);
+        expect(await libTxDecoder.decodeZeroExTransactionData.callAsync(input)).to.deep.equal([
+            'cancelOrder',
+            [order],
+            [],
+            [],
+        ]);
+    });
+
+    for (const func of ['fillOrder', 'fillOrderNoThrow', 'fillOrKillOrder']) {
+        const input = (exchangeInterface as any)[func].getABIEncodedTransactionData(
+            order,
+            takerAssetFillAmount,
+            signature,
+        );
+        it(`should decode an Exchange.${func}() transaction`, async () => {
+            expect(await libTxDecoder.decodeZeroExTransactionData.callAsync(input)).to.deep.equal([
+                func,
+                [order],
+                [takerAssetFillAmount],
+                [signature],
+            ]);
+        });
+    }
+
+    for (const func of ['marketBuyOrders', 'marketBuyOrdersNoThrow', 'marketSellOrders', 'marketSellOrdersNoThrow']) {
+        const input = (exchangeInterface as any)[func].getABIEncodedTransactionData(
+            [order, order],
+            takerAssetFillAmount,
+            [signature, signature],
+        );
+        it(`should decode an Exchange.${func}() transaction`, async () => {
+            expect(await libTxDecoder.decodeZeroExTransactionData.callAsync(input)).to.deep.equal([
+                func,
+                [order, order],
+                [takerAssetFillAmount],
+                [signature, signature],
+            ]);
+        });
+    }
+
+    it('should decode an Exchange.matchOrders() transaction', async () => {
+        const complementaryOrder = {
+            ...order,
+            makerAddress: order.takerAddress,
+            takerAddress: order.makerAddress,
+            makerAssetData: order.takerAssetData,
+            takerAssetData: order.makerAssetData,
+            makerAssetAmount: order.takerAssetAmount,
+            takerAssetAmount: order.makerAssetAmount,
+            makerFee: order.takerFee,
+            takerFee: order.makerFee,
+        };
+        const input = exchangeInterface.matchOrders.getABIEncodedTransactionData(
+            order,
+            complementaryOrder,
+            signature,
+            signature,
+        );
+        expect(await libTxDecoder.decodeZeroExTransactionData.callAsync(input)).to.deep.equal([
+            'matchOrders',
+            [order, complementaryOrder],
+            [order.takerAssetAmount, complementaryOrder.takerAssetAmount],
+            [signature, signature],
+        ]);
+    });
+});

contracts/dev-utils/test/order_validation_utils.ts

@@ -0,0 +1,445 @@
+import {
+    artifacts as proxyArtifacts,
+    ERC20ProxyContract,
+    ERC20Wrapper,
+    ERC721ProxyContract,
+    ERC721Wrapper,
+    MultiAssetProxyContract,
+} from '@0x/contracts-asset-proxy';
+import { DummyERC20TokenContract } from '@0x/contracts-erc20';
+import { DummyERC721TokenContract } from '@0x/contracts-erc721';
+import { artifacts as exchangeArtifacts, ExchangeContract, ExchangeWrapper } from '@0x/contracts-exchange';
+import {
+    chaiSetup,
+    constants,
+    OrderFactory,
+    OrderStatus,
+    provider,
+    txDefaults,
+    web3Wrapper,
+} from '@0x/contracts-test-utils';
+import { BlockchainLifecycle } from '@0x/dev-utils';
+import { assetDataUtils, orderHashUtils } from '@0x/order-utils';
+import { SignedOrder } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+import * as chai from 'chai';
+
+import { artifacts, DevUtilsContract } from '../src';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+describe('OrderValidationUtils', () => {
+    let makerAddress: string;
+    let takerAddress: string;
+    let owner: string;
+    let erc20AssetData: string;
+    let erc20AssetData2: string;
+    let erc721AssetData: string;
+    let zrxAssetData: string;
+
+    let erc20Token: DummyERC20TokenContract;
+    let erc20Token2: DummyERC20TokenContract;
+    let zrxToken: DummyERC20TokenContract;
+    let erc721Token: DummyERC721TokenContract;
+    let exchange: ExchangeContract;
+    let devUtils: DevUtilsContract;
+    let erc20Proxy: ERC20ProxyContract;
+    let erc721Proxy: ERC721ProxyContract;
+    let multiAssetProxy: MultiAssetProxyContract;
+
+    let signedOrder: SignedOrder;
+    let orderFactory: OrderFactory;
+
+    const tokenId = new BigNumber(123456789);
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    before(async () => {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        const usedAddresses = ([owner, makerAddress, takerAddress] = accounts.slice(0, 3));
+
+        const erc20Wrapper = new ERC20Wrapper(provider, usedAddresses, owner);
+        const erc721Wrapper = new ERC721Wrapper(provider, usedAddresses, owner);
+
+        const numDummyErc20ToDeploy = 3;
+        [erc20Token, zrxToken, erc20Token2] = await erc20Wrapper.deployDummyTokensAsync(
+            numDummyErc20ToDeploy,
+            constants.DUMMY_TOKEN_DECIMALS,
+        );
+        erc20Proxy = await erc20Wrapper.deployProxyAsync();
+
+        [erc721Token] = await erc721Wrapper.deployDummyTokensAsync();
+        erc721Proxy = await erc721Wrapper.deployProxyAsync();
+
+        zrxAssetData = assetDataUtils.encodeERC20AssetData(zrxToken.address);
+        exchange = await ExchangeContract.deployFrom0xArtifactAsync(
+            exchangeArtifacts.Exchange,
+            provider,
+            txDefaults,
+            artifacts,
+            zrxAssetData,
+        );
+
+        multiAssetProxy = await MultiAssetProxyContract.deployFrom0xArtifactAsync(
+            proxyArtifacts.MultiAssetProxy,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+        const exchangeWrapper = new ExchangeWrapper(exchange, provider);
+        await exchangeWrapper.registerAssetProxyAsync(erc20Proxy.address, owner);
+        await exchangeWrapper.registerAssetProxyAsync(erc721Proxy.address, owner);
+        await exchangeWrapper.registerAssetProxyAsync(multiAssetProxy.address, owner);
+        await erc20Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(exchange.address, { from: owner });
+        await erc721Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(exchange.address, { from: owner });
+
+        devUtils = await DevUtilsContract.deployFrom0xArtifactAsync(
+            artifacts.DevUtils,
+            provider,
+            txDefaults,
+            artifacts,
+            exchange.address,
+            zrxAssetData,
+        );
+
+        erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
+        erc20AssetData2 = assetDataUtils.encodeERC20AssetData(erc20Token2.address);
+        erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, tokenId);
+        const defaultOrderParams = {
+            ...constants.STATIC_ORDER_PARAMS,
+            exchangeAddress: exchange.address,
+            makerAddress,
+            feeRecipientAddress: constants.NULL_ADDRESS,
+            makerAssetData: erc20AssetData,
+            takerAssetData: erc20AssetData2,
+        };
+        const privateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
+        orderFactory = new OrderFactory(privateKey, defaultOrderParams);
+    });
+
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    describe('getTransferableAssetAmount', () => {
+        it('should return the balance when balance < allowance', async () => {
+            const balance = new BigNumber(123);
+            const allowance = new BigNumber(456);
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, balance);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
+                from: makerAddress,
+            });
+            const transferableAmount = await devUtils.getTransferableAssetAmount.callAsync(
+                makerAddress,
+                erc20AssetData,
+            );
+            expect(transferableAmount).to.bignumber.equal(balance);
+        });
+        it('should return the allowance when allowance < balance', async () => {
+            const balance = new BigNumber(456);
+            const allowance = new BigNumber(123);
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, balance);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
+                from: makerAddress,
+            });
+            const transferableAmount = await devUtils.getTransferableAssetAmount.callAsync(
+                makerAddress,
+                erc20AssetData,
+            );
+            expect(transferableAmount).to.bignumber.equal(allowance);
+        });
+        it('should return the correct transferable amount for multiAssetData', async () => {
+            const multiAssetData = assetDataUtils.encodeMultiAssetData(
+                [new BigNumber(1), new BigNumber(1)],
+                [erc20AssetData, erc20AssetData2],
+            );
+            const transferableAmount1 = new BigNumber(10);
+            const transferableAmount2 = new BigNumber(5);
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, transferableAmount1);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, transferableAmount1, {
+                from: makerAddress,
+            });
+            await erc20Token2.setBalance.awaitTransactionSuccessAsync(makerAddress, transferableAmount2);
+            await erc20Token2.approve.awaitTransactionSuccessAsync(erc20Proxy.address, transferableAmount2, {
+                from: makerAddress,
+            });
+            const transferableAmount = await devUtils.getTransferableAssetAmount.callAsync(
+                makerAddress,
+                multiAssetData,
+            );
+            expect(transferableAmount).to.bignumber.equal(transferableAmount2);
+        });
+    });
+    describe('getOrderRelevantState', () => {
+        beforeEach(async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync();
+        });
+        it('should return the correct orderInfo when the order is valid', async () => {
+            const [orderInfo] = await devUtils.getOrderRelevantState.callAsync(signedOrder, signedOrder.signature);
+            expect(orderInfo.orderHash).to.equal(orderHashUtils.getOrderHashHex(signedOrder));
+            expect(orderInfo.orderStatus).to.equal(OrderStatus.Fillable);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return isValidSignature=true when the signature is valid', async () => {
+            const [, , isValidSignature] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                signedOrder.signature,
+            );
+            expect(isValidSignature).to.equal(true);
+        });
+        it('should return isValidSignature=false when the signature is invalid', async () => {
+            const invalidSignature = '0x01';
+            const [, , isValidSignature] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                invalidSignature,
+            );
+            expect(isValidSignature).to.equal(false);
+        });
+        it('should return a fillableTakerAssetAmount of 0 when balances or allowances are insufficient', async () => {
+            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                signedOrder.signature,
+            );
+            expect(fillableTakerAssetAmount).to.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return a fillableTakerAssetAmount of 0 when fee balances/allowances are insufficient', async () => {
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                signedOrder.signature,
+            );
+            expect(fillableTakerAssetAmount).to.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return a fillableTakerAssetAmount of 0 when balances/allowances of one asset within a multiAssetData are insufficient', async () => {
+            const multiAssetData = assetDataUtils.encodeMultiAssetData(
+                [new BigNumber(1), new BigNumber(1)],
+                [erc20AssetData, erc20AssetData2],
+            );
+            signedOrder = await orderFactory.newSignedOrderAsync({ makerAssetData: multiAssetData });
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                signedOrder.signature,
+            );
+            expect(fillableTakerAssetAmount).to.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return the correct fillableTakerAssetAmount when fee balances/allowances are partially sufficient', async () => {
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            const divisor = 4;
+            await zrxToken.setBalance.awaitTransactionSuccessAsync(
+                makerAddress,
+                signedOrder.makerFee.dividedToIntegerBy(divisor),
+            );
+            await zrxToken.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerFee, {
+                from: makerAddress,
+            });
+            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                signedOrder.signature,
+            );
+            expect(fillableTakerAssetAmount).to.bignumber.equal(
+                signedOrder.takerAssetAmount.dividedToIntegerBy(divisor),
+            );
+        });
+        it('should return the correct fillableTakerAssetAmount when non-fee balances/allowances are partially sufficient', async () => {
+            const divisor = 4;
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(
+                makerAddress,
+                signedOrder.makerAssetAmount.dividedToIntegerBy(divisor),
+            );
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            await zrxToken.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerFee);
+            await zrxToken.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerFee, {
+                from: makerAddress,
+            });
+            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                signedOrder.signature,
+            );
+            expect(fillableTakerAssetAmount).to.bignumber.equal(
+                signedOrder.takerAssetAmount.dividedToIntegerBy(divisor),
+            );
+        });
+        it('should return the correct fillableTakerAssetAmount when balances/allowances of one asset within a multiAssetData are partially sufficient', async () => {
+            const multiAssetData = assetDataUtils.encodeMultiAssetData(
+                [new BigNumber(1), new BigNumber(1)],
+                [erc20AssetData, erc20AssetData2],
+            );
+            signedOrder = await orderFactory.newSignedOrderAsync({ makerAssetData: multiAssetData });
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            await zrxToken.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerFee);
+            await zrxToken.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerFee, {
+                from: makerAddress,
+            });
+            const divisor = 4;
+            await erc20Token2.setBalance.awaitTransactionSuccessAsync(
+                makerAddress,
+                signedOrder.makerAssetAmount.dividedToIntegerBy(divisor),
+            );
+            await erc20Token2.approve.awaitTransactionSuccessAsync(
+                erc20Proxy.address,
+                signedOrder.makerAssetAmount.dividedToIntegerBy(divisor),
+                {
+                    from: makerAddress,
+                },
+            );
+            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                signedOrder.signature,
+            );
+            expect(fillableTakerAssetAmount).to.bignumber.equal(
+                signedOrder.takerAssetAmount.dividedToIntegerBy(divisor),
+            );
+        });
+        it('should return a fillableTakerAssetAmount of 0 when non-fee balances/allowances are insufficient', async () => {
+            await zrxToken.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerFee);
+            await zrxToken.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerFee, {
+                from: makerAddress,
+            });
+            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                signedOrder.signature,
+            );
+            expect(fillableTakerAssetAmount).to.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return a fillableTakerAssetAmount equal to the takerAssetAmount when the order is unfilled and balances/allowances are sufficient', async () => {
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            await zrxToken.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerFee);
+            await zrxToken.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerFee, {
+                from: makerAddress,
+            });
+            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                signedOrder.signature,
+            );
+            expect(fillableTakerAssetAmount).to.bignumber.equal(signedOrder.takerAssetAmount);
+        });
+        it('should return the correct fillableTakerAssetAmount when balances/allowances are partially sufficient and makerAsset=makerFeeAsset', async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync({
+                makerAssetData: zrxAssetData,
+                makerAssetAmount: new BigNumber(10),
+                takerAssetAmount: new BigNumber(20),
+                makerFee: new BigNumber(40),
+            });
+            const transferableMakerAssetAmount = new BigNumber(10);
+            await zrxToken.setBalance.awaitTransactionSuccessAsync(makerAddress, transferableMakerAssetAmount);
+            await zrxToken.approve.awaitTransactionSuccessAsync(erc20Proxy.address, transferableMakerAssetAmount, {
+                from: makerAddress,
+            });
+            const expectedFillableTakerAssetAmount = transferableMakerAssetAmount
+                .times(signedOrder.takerAssetAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount.plus(signedOrder.makerFee));
+            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                signedOrder.signature,
+            );
+            expect(fillableTakerAssetAmount).to.bignumber.equal(expectedFillableTakerAssetAmount);
+        });
+        it('should return the correct fillabeTakerassetAmount when makerAsset balances/allowances are sufficient and there are no maker fees', async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync({ makerFee: constants.ZERO_AMOUNT });
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                signedOrder.signature,
+            );
+            expect(fillableTakerAssetAmount).to.bignumber.equal(signedOrder.takerAssetAmount);
+        });
+        it('should return a fillableTakerAssetAmount when the remaining takerAssetAmount is less than the transferable amount', async () => {
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            await zrxToken.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerFee);
+            await zrxToken.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerFee, {
+                from: makerAddress,
+            });
+            await erc20Token2.setBalance.awaitTransactionSuccessAsync(takerAddress, signedOrder.takerAssetAmount);
+            await erc20Token2.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.takerAssetAmount, {
+                from: takerAddress,
+            });
+            await zrxToken.setBalance.awaitTransactionSuccessAsync(takerAddress, signedOrder.takerFee);
+
+            await zrxToken.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.takerFee, {
+                from: takerAddress,
+            });
+            const takerAssetFillAmount = signedOrder.takerAssetAmount.dividedToIntegerBy(4);
+            await exchange.fillOrder.awaitTransactionSuccessAsync(
+                signedOrder,
+                takerAssetFillAmount,
+                signedOrder.signature,
+                { from: takerAddress },
+            );
+            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState.callAsync(
+                signedOrder,
+                signedOrder.signature,
+            );
+            expect(fillableTakerAssetAmount).to.bignumber.equal(
+                signedOrder.takerAssetAmount.minus(takerAssetFillAmount),
+            );
+        });
+    });
+    describe('getOrderRelevantStates', async () => {
+        it('should return the correct information for multiple orders', async () => {
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount);
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            await zrxToken.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerFee);
+            await zrxToken.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerFee, {
+                from: makerAddress,
+            });
+            const signedOrder2 = await orderFactory.newSignedOrderAsync({ makerAssetData: erc721AssetData });
+            const invalidSignature = '0x01';
+            await exchange.cancelOrder.awaitTransactionSuccessAsync(signedOrder2, { from: makerAddress });
+            const [
+                ordersInfo,
+                fillableTakerAssetAmounts,
+                isValidSignature,
+            ] = await devUtils.getOrderRelevantStates.callAsync(
+                [signedOrder, signedOrder2],
+                [signedOrder.signature, invalidSignature],
+            );
+            expect(ordersInfo[0].orderHash).to.equal(orderHashUtils.getOrderHashHex(signedOrder));
+            expect(ordersInfo[1].orderHash).to.equal(orderHashUtils.getOrderHashHex(signedOrder2));
+            expect(ordersInfo[0].orderStatus).to.equal(OrderStatus.Fillable);
+            expect(ordersInfo[1].orderStatus).to.equal(OrderStatus.Cancelled);
+            expect(ordersInfo[0].orderTakerAssetFilledAmount).to.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(ordersInfo[1].orderTakerAssetFilledAmount).to.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(fillableTakerAssetAmounts[0]).to.bignumber.equal(signedOrder.takerAssetAmount);
+            expect(fillableTakerAssetAmounts[1]).to.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(isValidSignature[0]).to.equal(true);
+            expect(isValidSignature[1]).to.equal(false);
+        });
+    });
+});
+// tslint:disable:max-file-line-count

contracts/dev-utils/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "extends": "../../tsconfig",
+    "compilerOptions": { "outDir": "lib", "rootDir": ".", "resolveJsonModule": true },
+    "include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*"],
+    "files": [
+        "generated-artifacts/DevUtils.json",
+        "generated-artifacts/LibAssetData.json",
+        "generated-artifacts/LibTransactionDecoder.json",
+        "generated-artifacts/EthBalanceChecker.json"
+    ],
+    "exclude": ["./deploy/solc/solc_bin"]
+}

contracts/dev-utils/tslint.json

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