Publish

- @0x/contracts-asset-proxy@3.1.1
 - @0x/contracts-coordinator@3.0.4
 - @0x/contracts-dev-utils@1.0.4
 - @0x/contracts-erc1155@2.0.4
 - @0x/contracts-erc20-bridge-sampler@1.1.0
 - @0x/contracts-erc20@3.0.4
 - @0x/contracts-erc721@3.0.4
 - @0x/contracts-exchange-forwarder@4.0.4
 - @0x/contracts-exchange-libs@4.1.0
 - @0x/contracts-exchange@3.1.0
 - @0x/contracts-extensions@5.1.3
 - @0x/contracts-integrations@2.2.0
 - @0x/contracts-multisig@4.0.4
 - @0x/contracts-staking@2.0.4
 - @0x/contracts-test-utils@5.1.1
 - @0x/contracts-utils@4.1.0
 - 0x.js@9.0.4
 - @0x/abi-gen@5.1.0
 - @0x/assert@3.0.4
 - @0x/asset-swapper@4.0.0
 - @0x/base-contract@6.1.0
 - @0x/connect@6.0.4
 - @0x/contract-addresses@4.3.0
 - @0x/contract-artifacts@3.4.0
 - @0x/contract-wrappers-test@12.2.5
 - @0x/contract-wrappers@13.4.0
 - @0x/contracts-gen@2.0.4
 - @0x/dev-utils@3.1.1
 - @0x/instant@1.0.41
 - @0x/json-schemas@5.0.4
 - @0x/migrations@6.0.0
 - @0x/monorepo-scripts@1.0.47
 - @0x/order-utils@10.1.1
 - @0x/orderbook@2.1.0
 - @0x/sol-compiler@4.0.4
 - @0x/sol-coverage@4.0.4
 - @0x/sol-doc@3.1.1
 - @0x/sol-profiler@4.0.4
 - @0x/sol-trace@3.0.4
 - @0x/sol-tracing-utils@7.0.4
 - @0x/sra-spec@3.0.4
 - @0x/subproviders@6.0.4
 - @0x/utils@5.2.0
 - @0x/web3-wrapper@7.0.4

.circleci/config.yml

@@ -23,7 +23,7 @@ jobs:
             #       command: npm set prefix=/home/circleci/npm && echo 'export PATH=$HOME/circleci/npm/bin:$PATH' >> /home/circleci/.bashrc
             - run:
                   name: install-yarn
-                  command: npm install --global yarn@1.17.0
+                  command: npm install --force --global yarn@1.17.0
             - run:
                   name: yarn
                   command: yarn --frozen-lockfile --ignore-engines install || yarn --frozen-lockfile --ignore-engines install
@@ -37,7 +37,7 @@ jobs:
             - store_artifacts:
                   path: ~/repo/packages/abi-gen/test-cli/output
             - store_artifacts:
-                  path: ~/repo/packages/abi-gen-wrappers/generated_docs
+                  path: ~/repo/packages/contract-wrappers/generated_docs
     test-contracts-ganache:
         resource_class: medium+
         docker:
@@ -47,7 +47,7 @@ jobs:
             - restore_cache:
                   keys:
                       - repo-{{ .Environment.CIRCLE_SHA1 }}
-            - 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 @0x/contracts-staking
+            - 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-tests @0x/contracts-staking
     test-exchange-ganache-3.0:
         resource_class: medium+
         docker:
@@ -58,6 +58,16 @@ jobs:
                   keys:
                       - repo-{{ .Environment.CIRCLE_SHA1 }}
             - run: yarn wsrun test:circleci @0x/contracts-exchange
+    test-integrations-ganache-3.0:
+        resource_class: medium+
+        docker:
+            - image: nikolaik/python-nodejs:python3.7-nodejs8
+        working_directory: ~/repo
+        steps:
+            - restore_cache:
+                  keys:
+                      - repo-{{ .Environment.CIRCLE_SHA1 }}
+            - run: yarn wsrun test:circleci @0x/contracts-integrations
     test-contracts-rest-ganache-3.0:
         resource_class: medium+
         docker:
@@ -67,11 +77,11 @@ jobs:
             - restore_cache:
                   keys:
                       - repo-{{ .Environment.CIRCLE_SHA1 }}
-            - 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-asset-proxy @0x/contracts-exchange-forwarder @0x/contracts-dev-utils @0x/contracts-staking
-            # TODO(dorothy-zbornak): Re-enable after updating this package for 3.0.
+            - 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-asset-proxy @0x/contracts-exchange-forwarder @0x/contracts-tests @0x/contracts-staking @0x/contracts-coordinator @0x/contracts-erc20-bridge-sampler
+            # TODO(dorothy-zbornak): Re-enable after updating this package for
+            # 3.0. At that time, also remove exclusion from monorepo
+            # package.json's test script.
             # - run: yarn wsrun test:circleci @0x/contracts-extensions
-            # TODO(abandeali): Re-enable after this package is complete.
-            # - run: yarn wsrun test:circleci @0x/contracts-coordinator
     test-publish:
         resource_class: medium+
         docker:
@@ -82,9 +92,9 @@ jobs:
             - restore_cache:
                   keys:
                       - repo-{{ .Environment.CIRCLE_SHA1 }}
-            - run: 
-                command: yarn test:publish:circleci
-                no_output_timeout: 1800
+            - run:
+                  command: yarn test:publish:circleci
+                  no_output_timeout: 1800
     test-doc-generation:
         docker:
             - image: nikolaik/python-nodejs:python3.7-nodejs8
@@ -94,8 +104,8 @@ jobs:
                   keys:
                       - repo-{{ .Environment.CIRCLE_SHA1 }}
             - run:
-                command: yarn test:generate_docs:circleci
-                no_output_timeout: 1200
+                  command: yarn test:generate_docs:circleci
+                  no_output_timeout: 1200
     test-rest:
         docker:
             - image: nikolaik/python-nodejs:python3.7-nodejs8
@@ -106,17 +116,16 @@ jobs:
                       - repo-{{ .Environment.CIRCLE_SHA1 }}
             - run: yarn wsrun test:circleci @0x/contracts-test-utils
             - run: yarn wsrun test:circleci @0x/abi-gen
-            # TODO (xianny): Needs to be updated for 3.0
-            # - run: yarn wsrun test:circleci @0x/asset-buyer
+            - run: yarn wsrun test:circleci @0x/asset-swapper
             - run: yarn wsrun test:circleci @0x/contract-artifacts
             - run: yarn wsrun test:circleci @0x/assert
             - run: yarn wsrun test:circleci @0x/base-contract
-            # TODO (xianny): Needs to be updated for 3.0
-            # - run: yarn wsrun test:circleci @0x/connect
-            - run: yarn wsrun test:circleci @0x/contract-wrappers
+            - run: yarn wsrun test:circleci @0x/connect
+            - run: yarn wsrun test:circleci @0x/contract-wrappers-test
             - run: yarn wsrun test:circleci @0x/dev-utils
             - run: yarn wsrun test:circleci @0x/json-schemas
             - run: yarn wsrun test:circleci @0x/order-utils
+            - run: yarn wsrun test:circleci @0x/orderbook
             - run: yarn wsrun test:circleci @0x/sol-compiler
             - run: yarn wsrun test:circleci @0x/sol-tracing-utils
             - run: yarn wsrun test:circleci @0x/sol-doc
@@ -133,9 +142,9 @@ jobs:
                   paths:
                       - ~/repo/packages/assert/coverage/lcov.info
             - save_cache:
-                  key: coverage-asset-buyer-{{ .Environment.CIRCLE_SHA1 }}
+                  key: coverage-asset-swapper-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
-                      - ~/repo/packages/asset-buyer/coverage/lcov.info
+                      - ~/repo/packages/asset-swapper/coverage/lcov.info
             - save_cache:
                   key: coverage-base-contract-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
@@ -145,9 +154,9 @@ jobs:
                   paths:
                       - ~/repo/packages/connect/coverage/lcov.info
             - save_cache:
-                  key: coverage-contract-wrappers-{{ .Environment.CIRCLE_SHA1 }}
+                  key: coverage-contract-wrappers-test-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
-                      - ~/repo/packages/contract-wrappers/coverage/lcov.info
+                      - ~/repo/packages/contract-wrappers-test/coverage/lcov.info
             - save_cache:
                   key: coverage-dev-utils-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
@@ -184,14 +193,27 @@ jobs:
         working_directory: ~/repo
         docker:
             - image: nikolaik/python-nodejs:python3.7-nodejs8
-            - image: 0xorg/ganache-cli:2.2.2
-            - image: 0xorg/launch-kit-backend:74bcc39
+            - image: 0xorg/ganache-cli:6.0.0
+            - image: 0xorg/mesh:0xV3
               environment:
-                  RPC_URL: http://localhost:8545
-                  NETWORK_ID: 50
-                  WHITELIST_ALL_TOKENS: True
+                  ETHEREUM_RPC_URL: 'http://localhost:8545'
+                  ETHEREUM_CHAIN_ID: '1337'
+                  VERBOSITY: 5
+                  BLOCK_POLLING_INTERVAL: '50ms'
+                  ETHEREUM_RPC_MAX_REQUESTS_PER_24_HR_UTC: '1778000'
               command: |
-                  sh -c "until printf 'POST /\r\nContent-Length: 26\r\n\r\n{\"method\":\"net_listening\"}' | nc localhost 8545 | grep true; do continue; done; node_modules/.bin/forever ts/lib/index.js"
+                  sh -c "waitForGanache () { until printf 'POST /\r\nContent-Length: 26\r\n\r\n{\"method\":\"net_listening\"}' | nc localhost 8545 | grep true; do continue; done }; waitForGanache && ./mesh"
+            - image: 0xorg/launch-kit-backend:v3
+              environment:
+                  RPC_URL: 'http://localhost:8545'
+                  CHAIN_ID: 1337
+                  WHITELIST_ALL_TOKENS: True
+                  FEE_RECIPIENT: '0x0000000000000000000000000000000000000001'
+                  MAKER_FEE_UNIT_AMOUNT: 0
+                  TAKER_FEE_UNIT_AMOUNT: 0
+                  MESH_ENDPOINT: 'ws://localhost:60557'
+              command: |
+                  sh -c "waitForMesh () { sleep 30; }; waitForMesh && node_modules/.bin/forever ts/lib/index.js"
         steps:
             - checkout
             - restore_cache:
@@ -213,8 +235,14 @@ jobs:
             - run:
                   command: |
                       cd python-packages
-                      ./parallel_without_sra_client coverage run setup.py test
+                      ./parallel coverage run setup.py test
                       ./build_docs
+            - run:
+                  command: |
+                      # copy generated wrappers into contract_wrappers/build,
+                      # JUST so CircleCI will persist them as build artifacts.
+                      cd python-packages/contract_wrappers/src/zero_ex
+                      for i in contract_wrappers/[^__]*/; do mkdir -p ../../build/$i; cp $i/__init__.py ../../build/$i; done
             - save_cache:
                   key: coverage-python-contract-addresses-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
@@ -239,8 +267,6 @@ 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/*/__init__.py
             - store_artifacts:
                   path: ~/repo/python-packages/contract_addresses/build
             - store_artifacts:
@@ -330,7 +356,7 @@ jobs:
                       - coverage-assert-{{ .Environment.CIRCLE_SHA1 }}
             - restore_cache:
                   keys:
-                      - coverage-asset-buyer-{{ .Environment.CIRCLE_SHA1 }}
+                      - coverage-asset-swapper-{{ .Environment.CIRCLE_SHA1 }}
             - restore_cache:
                   keys:
                       - coverage-base-contract-{{ .Environment.CIRCLE_SHA1 }}
@@ -339,7 +365,7 @@ jobs:
                       - coverage-connect-{{ .Environment.CIRCLE_SHA1 }}
             - restore_cache:
                   keys:
-                      - coverage-contract-wrappers-{{ .Environment.CIRCLE_SHA1 }}
+                      - coverage-contract-wrappers-test-{{ .Environment.CIRCLE_SHA1 }}
             - restore_cache:
                   keys:
                       - coverage-dev-utils-{{ .Environment.CIRCLE_SHA1 }}
@@ -394,6 +420,9 @@ workflows:
             - test-exchange-ganache-3.0:
                   requires:
                       - build
+            - test-integrations-ganache-3.0:
+                  requires:
+                      - build
             - test-contracts-rest-ganache-3.0:
                   requires:
                       - build
@@ -415,12 +444,11 @@ workflows:
                       - test-exchange-ganache-3.0
                       - test-rest
                       - static-tests
-            # - test-python:
-            #       requires:
-            #           - build
-            #           - test-rest
-            # - static-tests-python:
-            #       requires:
-            #           - test-python
+            - test-python:
+                  requires:
+                      - build
+            - static-tests-python:
+                  requires:
+                      - build
             # skip python tox run for now, as we don't yet have multiple test environments to support.
             # - test-rest-python

.github/autolabeler.yml

@@ -19,18 +19,15 @@ contracts: ['contracts']
 @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/asset-swapper: ['packages/asset-swapper']
 @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']
-@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/testnet-faucets: ['packages/testnet-faucets']
-@0x/monorepo-scripts: ['packages/monorepo-scripts']

.gitignore

@@ -78,27 +78,42 @@ TODO.md
 # VSCode file
 .vscode
 
-# server cli
-packages/testnet-faucets/server/
-
 # generated contract artifacts/
+contracts/erc20-bridge-sampler/generated-artifacts/
+contracts/erc20-bridge-sampler/test/generated-artifacts/
+contracts/integrations/generated-artifacts/
+contracts/integrations/test/generated-artifacts/
 contracts/staking/generated-artifacts/
+contracts/staking/test/generated-artifacts/
 contracts/coordinator/generated-artifacts/
+contracts/coordinator/test/generated-artifacts/
 contracts/exchange/generated-artifacts/
+contracts/exchange/test/generated-artifacts/
 contracts/asset-proxy/generated-artifacts/
+contracts/asset-proxy/test/generated-artifacts/
 contracts/multisig/generated-artifacts/
+contracts/multisig/test/generated-artifacts/
 contracts/utils/generated-artifacts/
+contracts/utils/test/generated-artifacts/
 contracts/exchange-libs/generated-artifacts/
+contracts/exchange-libs/test/generated-artifacts/
 contracts/erc20/generated-artifacts/
+contracts/erc20/test/generated-artifacts/
 contracts/erc721/generated-artifacts/
+contracts/erc721/test/generated-artifacts/
 contracts/erc1155/generated-artifacts/
+contracts/erc1155/test/generated-artifacts/
 contracts/extensions/generated-artifacts/
+contracts/extensions/test/generated-artifacts/
 contracts/exchange-forwarder/generated-artifacts/
+contracts/exchange-forwarder/test/generated-artifacts/
 contracts/dev-utils/generated-artifacts/
+contracts/dev-utils/test/generated-artifacts/
 packages/sol-tracing-utils/test/fixtures/artifacts/
 python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/
 
 # generated truffle contract artifacts/
+contracts/erc20-bridge-sampler/build/
 contracts/staking/build/
 contracts/coordinator/build/
 contracts/exchange/build/
@@ -115,39 +130,37 @@ contracts/dev-utils/build/
 
 # generated contract wrappers
 packages/python-contract-wrappers/generated/
+contracts/erc20-bridge-sampler/generated-wrappers/
+contracts/erc20-bridge-sampler/test/generated-wrappers/
+contracts/integrations/generated-wrappers/
+contracts/integrations/test/generated-wrappers/
 contracts/staking/generated-wrappers/
+contracts/staking/test/generated-wrappers/
 contracts/coordinator/generated-wrappers/
+contracts/coordinator/test/generated-wrappers/
 contracts/exchange/generated-wrappers/
+contracts/exchange/test/generated-wrappers/
 contracts/asset-proxy/generated-wrappers/
+contracts/asset-proxy/test/generated-wrappers/
 contracts/multisig/generated-wrappers/
+contracts/multisig/test/generated-wrappers/
 contracts/utils/generated-wrappers/
+contracts/utils/test/generated-wrappers/
 contracts/exchange-libs/generated-wrappers/
+contracts/exchange-libs/test/generated-wrappers/
 contracts/erc20/generated-wrappers/
+contracts/erc20/test/generated-wrappers/
 contracts/erc721/generated-wrappers/
+contracts/erc721/test/generated-wrappers/
 contracts/erc1155/generated-wrappers/
+contracts/erc1155/test/generated-wrappers/
 contracts/extensions/generated-wrappers/
+contracts/extensions/test/generated-wrappers/
 contracts/exchange-forwarder/generated-wrappers/
+contracts/exchange-forwarder/test/generated-wrappers/
 contracts/dev-utils/generated-wrappers/
-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
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/asset_proxy_owner/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/coordinator/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/coordinator_registry/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/dummy_erc20_token/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/dummy_erc721_token/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/dutch_auction/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc20_proxy/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc721_proxy/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc721_token/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/eth_balance_checker/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/forwarder/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/i_asset_proxy/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/i_validator/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/i_wallet/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/multi_asset_proxy/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/order_validator/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/weth9/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/zrx_token/__init__.py
+contracts/dev-utils/test/generated-wrappers/
+python-packages/contract_wrappers/src/zero_ex/contract_wrappers/*/__init__.py
 
 # solc-bin in sol-compiler
 packages/sol-compiler/solc_bin/
@@ -162,10 +175,14 @@ __pycache__
 python-packages/*/src/*.egg-info
 python-packages/*/.coverage
 
-# python keeps package-local copies of json schemas
+# python keeps package-local copies of json schemas and contract addresses
 python-packages/json_schemas/src/zero_ex/json_schemas/schemas
+python-packages/contract_addresses/src/zero_ex/contract_addresses/addresses.json
 
 # Doc README copy
 packages/*/docs/README.md
 
 .DS_Store
+
+# the snapshot that gets built for migrations sure does have a ton of files
+packages/migrations/0x_ganache_snapshot*

.prettierignore

@@ -1,31 +1,65 @@
 lib
 .nyc_output
+/contracts/integrations/generated-wrappers
+/contracts/integrations/test/generated-wrappers
+/contracts/integrations/generated-artifacts
+/contracts/integrations/test/generated-artifacts
 /contracts/staking/generated-wrappers
+/contracts/staking/test/generated-wrappers
 /contracts/staking/generated-artifacts
+/contracts/staking/test/generated-artifacts
 /contracts/coordinator/generated-wrappers
+/contracts/coordinator/test/generated-wrappers
 /contracts/coordinator/generated-artifacts
+/contracts/coordinator/test/generated-artifacts
 /contracts/exchange/generated-wrappers
+/contracts/exchange/test/generated-wrappers
 /contracts/exchange/generated-artifacts
+/contracts/exchange/test/generated-artifacts
 /contracts/asset-proxy/generated-wrappers
+/contracts/asset-proxy/test/generated-wrappers
 /contracts/asset-proxy/generated-artifacts
+/contracts/asset-proxy/test/generated-artifacts
 /contracts/multisig/generated-wrappers
+/contracts/multisig/test/generated-wrappers
 /contracts/multisig/generated-artifacts
+/contracts/multisig/test/generated-artifacts
 /contracts/utils/generated-wrappers
+/contracts/utils/test/generated-wrappers
 /contracts/utils/generated-artifacts
+/contracts/utils/test/generated-artifacts
 /contracts/exchange-libs/generated-wrappers
+/contracts/exchange-libs/test/generated-wrappers
 /contracts/exchange-libs/generated-artifacts
+/contracts/exchange-libs/test/generated-artifacts
 /contracts/erc20/generated-wrappers
+/contracts/erc20/test/generated-wrappers
 /contracts/erc20/generated-artifacts
+/contracts/erc20/test/generated-artifacts
+/contracts/erc20-bridge-sampler/generated-wrappers
+/contracts/erc20-bridge-sampler/test/generated-wrappers
+/contracts/erc20-bridge-sampler/generated-artifacts
+/contracts/erc20-bridge-sampler/test/generated-artifacts
 /contracts/erc721/generated-wrappers
+/contracts/erc721/test/generated-wrappers
 /contracts/erc721/generated-artifacts
+/contracts/erc721/test/generated-artifacts
 /contracts/erc1155/generated-wrappers
+/contracts/erc1155/test/generated-wrappers
 /contracts/erc1155/generated-artifacts
+/contracts/erc1155/test/generated-artifacts
 /contracts/extensions/generated-wrappers
+/contracts/extensions/test/generated-wrappers
 /contracts/extensions/generated-artifacts
+/contracts/extensions/test/generated-artifacts
 /contracts/exchange-forwarder/generated-wrappers
+/contracts/exchange-forwarder/test/generated-wrappers
 /contracts/exchange-forwarder/generated-artifacts
+/contracts/exchange-forwarder/test/generated-artifacts
 /contracts/dev-utils/generated-wrappers
+/contracts/dev-utils/test/generated-wrappers
 /contracts/dev-utils/generated-artifacts
+/contracts/dev-utils/test/generated-artifacts
 /contracts/staking/build/
 /contracts/coordinator/build/
 /contracts/exchange/build/

.prettierrc

@@ -1,6 +1,6 @@
 {
-    "tabWidth": 4,
     "printWidth": 120,
-    "trailingComma": all,
-    "singleQuote": true
+    "tabWidth": 4,
+    "singleQuote": true,
+    "trailingComma": "all"
 }

CODEOWNERS

@@ -5,8 +5,8 @@
 # https://git-scm.com/docs/gitignore#_pattern_format
 
 # Website
-packages/asset-buyer/  @BMillman19 @fragosti @steveklebanoff
-packages/instant/  @BMillman19 @fragosti @steveklebanoff
+packages/asset-swapper/  @BMillman19 @fragosti @dave4506
+packages/instant/  @BMillman19 @fragosti @dave4506
 
 # Dev tools & setup
 .circleci/ @LogvinovLeon
@@ -14,8 +14,8 @@ packages/abi-gen/ @feuGeneA
 packages/base-contract/ @xianny
 packages/connect/ @fragosti 
 packages/abi-gen-templates/ @feuGeneA @xianny
-packages/contract-addresses/ @albrow
-packages/contract-artifacts/ @albrow
+packages/contract-addresses/ @abandeali1
+packages/contract-artifacts/ @abandeali1
 packages/dev-utils/ @LogvinovLeon @fabioberger
 packages/devnet/ @albrow
 packages/ethereum-types/ @LogvinovLeon

README.md

@@ -61,11 +61,9 @@ These packages are all under development. See [/contracts/README.md](/contracts/
 | [`@0x/order-utils`](/packages/order-utils)               | [![npm](https://img.shields.io/npm/v/@0x/order-utils.svg)](https://www.npmjs.com/package/@0x/order-utils)               | A set of utilities for generating, parsing, signing and validating 0x orders                      |
 | [`@0x/json-schemas`](/packages/json-schemas)             | [![npm](https://img.shields.io/npm/v/@0x/json-schemas.svg)](https://www.npmjs.com/package/@0x/json-schemas)             | 0x-related JSON schemas                                                                           |  |
 | [`@0x/migrations`](/packages/migrations)                 | [![npm](https://img.shields.io/npm/v/@0x/migrations.svg)](https://www.npmjs.com/package/@0x/migrations)                 | Migration tool for deploying 0x smart contracts on private testnets                               |
-| [`@0x/contract-artifacts`](/packages/contract-artifacts) | [![npm](https://img.shields.io/npm/v/@0x/contract-artifacts.svg)](https://www.npmjs.com/package/@0x/contract-artifacts) | 0x smart contract compilation artifacts                                                           |
-| [`@0x/abi-gen-wrappers`](/packages/abi-gen-wrappers)     | [![npm](https://img.shields.io/npm/v/@0x/abi-gen-wrappers.svg)](https://www.npmjs.com/package/@0x/abi-gen-wrappers)     | Low-level 0x smart contract wrappers generated using `@0x/abi-gen`                                |
+| [`@0x/contract-artifacts`](/packages/contract-artifacts) | [![npm](https://img.shields.io/npm/v/@0x/contract-artifacts.svg)](https://www.npmjs.com/package/@0x/contract-artifacts) | 0x smart contract compilation artifacts                                                           |  |
 | [`@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
@@ -96,10 +94,9 @@ These packages are all under development. See [/contracts/README.md](/contracts/
 
 #### Private Packages
 
-| Package                                            | Description                                                                      |
-| -------------------------------------------------- | -------------------------------------------------------------------------------- |
-| [`@0x/instant`](/packages/instant)                 | A free and flexible way to offer simple crypto purchasing in any app or website. |
-| [`@0x/testnet-faucets`](/packages/testnet-faucets) | A faucet micro-service that dispenses test ERC20 tokens or Ether                 |
+| Package                            | Description                                                                      |
+| ---------------------------------- | -------------------------------------------------------------------------------- |
+| [`@0x/instant`](/packages/instant) | A free and flexible way to offer simple crypto purchasing in any app or website. |
 
 ## Usage
 

contracts/README.md

@@ -13,4 +13,4 @@
 
 #### 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.
+Building solidity files will update the contract artifact in `{package-name}/generated-artifacts/{contract}.json`, but does not automatically update the `contract-artifacts` or `contract-wrappers` packages, which are generated from the artifact JSON. See `contract-artifacts/README.md` for instructions on updating these packages.

contracts/asset-proxy/.npmignore

@@ -0,0 +1,10 @@
+# Blacklist all files
+.*
+*
+# Whitelist lib
+!lib/**/*
+# Whitelist Solidity contracts
+!contracts/src/**/*
+# Blacklist tests in lib
+/lib/test/*
+# Package specific ignore

contracts/asset-proxy/CHANGELOG.json

@@ -1,4 +1,142 @@
 [
+    {
+        "timestamp": 1579682890,
+        "version": "3.1.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "3.1.0",
+        "changes": [
+            {
+                "note": "Integration tests for DydxBridge with ERC20BridgeProxy.",
+                "pr": 2401
+            },
+            {
+                "note": "Fix `UniswapBridge` token -> token transfer call.",
+                "pr": 2412
+            },
+            {
+                "note": "Fix `KyberBridge` incorrect `minConversionRate` calculation.",
+                "pr": 2412
+            }
+        ],
+        "timestamp": 1578272714
+    },
+    {
+        "timestamp": 1576540892,
+        "version": "3.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1575931811,
+        "version": "3.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "3.0.0",
+        "changes": [
+            {
+                "note": "Implement `KyberBridge`.",
+                "pr": 2352
+            },
+            {
+                "note": "Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils",
+                "pr": 2330
+            },
+            {
+                "note": "ERC20Wrapper and ERC1155ProxyWrapper constructors now require an instance of DevUtilsContract",
+                "pr": 2034
+            },
+            {
+                "note": "Disallow the zero address from being made an authorized address in MixinAuthorizable, and created an archive directory that includes an old version of Ownable",
+                "pr": 2019
+            },
+            {
+                "note": "Remove `LibAssetProxyIds` contract",
+                "pr": 2055
+            },
+            {
+                "note": "Compile and export all contracts, artifacts, and wrappers by default",
+                "pr": 2055
+            },
+            {
+                "note": "Remove unused dependency on IAuthorizable in IAssetProxy",
+                "pr": 1910
+            },
+            {
+                "note": "Add `ERC20BridgeProxy`",
+                "pr": 2220
+            },
+            {
+                "note": "Add `Eth2DaiBridge`",
+                "pr": 2221
+            },
+            {
+                "note": "Add `UniswapBridge`",
+                "pr": 2233
+            },
+            {
+                "note": "Replaced `SafeMath` with `LibSafeMath`",
+                "pr": 2254
+            }
+        ],
+        "timestamp": 1575296764
+    },
+    {
+        "version": "2.3.0-beta.4",
+        "changes": [
+            {
+                "note": "Implement `KyberBridge`.",
+                "pr": 2352
+            },
+            {
+                "note": "Implement `DydxBridge`.",
+                "pr": 2365
+            }
+        ],
+        "timestamp": 1575290197
+    },
+    {
+        "version": "2.3.0-beta.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ],
+        "timestamp": 1574238768
+    },
+    {
+        "version": "2.3.0-beta.2",
+        "changes": [
+            {
+                "note": "Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils",
+                "pr": 2330
+            }
+        ],
+        "timestamp": 1574030254
+    },
+    {
+        "version": "2.3.0-beta.1",
+        "changes": [
+            {
+                "note": "ERC20Wrapper and ERC1155ProxyWrapper constructors now require an instance of DevUtilsContract",
+                "pr": 2034
+            }
+        ],
+        "timestamp": 1573159180
+    },
     {
         "version": "2.3.0-beta.0",
         "changes": [
@@ -25,6 +163,14 @@
             {
                 "note": "Add `Eth2DaiBridge`",
                 "pr": 2221
+            },
+            {
+                "note": "Add `UniswapBridge`",
+                "pr": 2233
+            },
+            {
+                "note": "Replaced `SafeMath` with `LibSafeMath`",
+                "pr": 2254
             }
         ],
         "timestamp": 1570135330

contracts/asset-proxy/CHANGELOG.md

@@ -5,6 +5,55 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v3.1.1 - _January 22, 2020_
+
+    * Dependencies updated
+
+## v3.1.0 - _January 6, 2020_
+
+    * Integration tests for DydxBridge with ERC20BridgeProxy. (#2401)
+    * Fix `UniswapBridge` token -> token transfer call. (#2412)
+    * Fix `KyberBridge` incorrect `minConversionRate` calculation. (#2412)
+
+## v3.0.2 - _December 17, 2019_
+
+    * Dependencies updated
+
+## v3.0.1 - _December 9, 2019_
+
+    * Dependencies updated
+
+## v3.0.0 - _December 2, 2019_
+
+    * Implement `KyberBridge`. (#2352)
+    * Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils (#2330)
+    * ERC20Wrapper and ERC1155ProxyWrapper constructors now require an instance of DevUtilsContract (#2034)
+    * Disallow the zero address from being made an authorized address in MixinAuthorizable, and created an archive directory that includes an old version of Ownable (#2019)
+    * Remove `LibAssetProxyIds` contract (#2055)
+    * Compile and export all contracts, artifacts, and wrappers by default (#2055)
+    * Remove unused dependency on IAuthorizable in IAssetProxy (#1910)
+    * Add `ERC20BridgeProxy` (#2220)
+    * Add `Eth2DaiBridge` (#2221)
+    * Add `UniswapBridge` (#2233)
+    * Replaced `SafeMath` with `LibSafeMath` (#2254)
+
+## v2.3.0-beta.4 - _December 2, 2019_
+
+    * Implement `KyberBridge`. (#2352)
+    * Implement `DydxBridge`. (#2365)
+
+## v2.3.0-beta.3 - _November 20, 2019_
+
+    * Dependencies updated
+
+## v2.3.0-beta.2 - _November 17, 2019_
+
+    * Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils (#2330)
+
+## v2.3.0-beta.1 - _November 7, 2019_
+
+    * ERC20Wrapper and ERC1155ProxyWrapper constructors now require an instance of DevUtilsContract (#2034)
+
 ## v2.3.0-beta.0 - _October 3, 2019_
 
     * Disallow the zero address from being made an authorized address in MixinAuthorizable, and created an archive directory that includes an old version of Ownable (#2019)
@@ -13,6 +62,8 @@ CHANGELOG
     * Remove unused dependency on IAuthorizable in IAssetProxy (#1910)
     * Add `ERC20BridgeProxy` (#2220)
     * Add `Eth2DaiBridge` (#2221)
+    * Add `UniswapBridge` (#2233)
+    * Replaced `SafeMath` with `LibSafeMath` (#2254)
 
 ## v2.2.8 - _September 17, 2019_
 

contracts/asset-proxy/compiler.json

@@ -1,10 +1,10 @@
 {
-    "artifactsDir": "./generated-artifacts",
+    "artifactsDir": "./test/generated-artifacts",
     "contractsDir": "./contracts",
     "useDockerisedSolc": false,
     "isOfflineMode": false,
     "compilerSettings": {
-        "evmVersion": "constantinople",
+        "evmVersion": "istanbul",
         "optimizer": {
             "enabled": true,
             "runs": 1000000,

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

@@ -19,7 +19,7 @@
 pragma solidity ^0.5.9;
 
 import "@0x/contracts-utils/contracts/src/LibBytes.sol";
-import "@0x/contracts-utils/contracts/src/SafeMath.sol";
+import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
 import "@0x/contracts-erc1155/contracts/src/interfaces/IERC1155.sol";
 import "../archive/MixinAuthorizable.sol";
 import "./interfaces/IAssetProxy.sol";
@@ -27,10 +27,10 @@ import "./interfaces/IAssetProxy.sol";
 
 contract ERC1155Proxy is
     MixinAuthorizable,
-    SafeMath,
     IAssetProxy
 {
     using LibBytes for bytes;
+    using LibSafeMath for uint256;
 
     // Id of this proxy.
     bytes4 constant internal PROXY_ID = bytes4(keccak256("ERC1155Assets(address,uint256[],uint256[],bytes)"));
@@ -71,7 +71,7 @@ contract ERC1155Proxy is
             // 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);
+            scaledValues[i] = values[i].safeMul(amount);
         }
 
         // Execute `safeBatchTransferFrom` call

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

@@ -73,7 +73,7 @@ contract ERC20BridgeProxy is
         uint256 balanceBefore = balanceOf(tokenAddress, to);
         // Call the bridge, who should transfer `amount` of `tokenAddress` to
         // `to`.
-        bytes4 success = IERC20Bridge(bridgeAddress).withdrawTo(
+        bytes4 success = IERC20Bridge(bridgeAddress).bridgeTransferFrom(
             tokenAddress,
             from,
             to,

contracts/asset-proxy/contracts/src/bridges/ChaiBridge.sol

@@ -0,0 +1,75 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
+
+import "../interfaces/IERC20Bridge.sol";
+import "../interfaces/IChai.sol";
+import "@0x/contracts-utils/contracts/src/DeploymentConstants.sol";
+import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
+
+
+// solhint-disable space-after-comma
+contract ChaiBridge is
+    IERC20Bridge,
+    DeploymentConstants
+{
+    /// @dev Withdraws `amount` of `from` address's Dai from the Chai contract.
+    ///      Transfers `amount` of Dai to `to` address.
+    /// @param from Address to transfer asset from.
+    /// @param to Address to transfer asset to.
+    /// @param amount Amount of asset to transfer.
+    /// @return success The magic bytes `0x37708e9b` if successful.
+    function bridgeTransferFrom(
+        address /* tokenAddress */,
+        address from,
+        address to,
+        uint256 amount,
+        bytes calldata /* bridgeData */
+    )
+        external
+        returns (bytes4 success)
+    {
+        // Ensure that only the `ERC20BridgeProxy` can call this function.
+        require(
+            msg.sender == _getERC20BridgeProxyAddress(),
+            "ChaiBridge/ONLY_CALLABLE_BY_ERC20_BRIDGE_PROXY"
+        );
+
+        // Withdraw `from` address's Dai.
+        // NOTE: This contract must be approved to spend Chai on behalf of `from`.
+        bytes memory drawCalldata = abi.encodeWithSelector(
+            IChai(address(0)).draw.selector,
+            from,
+            amount
+        );
+
+        (bool success,) = _getChaiAddress().call(drawCalldata);
+        require(
+            success,
+            "ChaiBridge/DRAW_DAI_FAILED"
+        );
+
+        // Transfer Dai to `to`
+        // This will never fail if the `draw` call was successful
+        IERC20Token(_getDaiAddress()).transfer(to, amount);
+
+        return BRIDGE_SUCCESS;
+    }
+}

contracts/asset-proxy/contracts/src/bridges/DydxBridge.sol

@@ -0,0 +1,241 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-utils/contracts/src/DeploymentConstants.sol";
+import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibMath.sol";
+import "../interfaces/IERC20Bridge.sol";
+import "../interfaces/IDydxBridge.sol";
+import "../interfaces/IDydx.sol";
+
+
+contract DydxBridge is
+    IERC20Bridge,
+    IDydxBridge,
+    DeploymentConstants
+{
+
+    using LibSafeMath for uint256;
+
+    /// @dev Callback for `IERC20Bridge`. Deposits or withdraws tokens from a dydx account.
+    ///      Notes:
+    ///         1. This bridge must be set as an operator of the input dydx account.
+    ///         2. This function may only be called in the context of the 0x Exchange.
+    ///         3. The maker or taker of the 0x order must be the dydx account owner.
+    ///         4. Deposits into dydx are made from the `from` address.
+    ///         5. Withdrawals from dydx are made to the `to` address.
+    ///         6. Calling this function must always withdraw at least `amount`,
+    ///            otherwise the `ERC20Bridge` will revert.
+    /// @param from The sender of the tokens and owner of the dydx account.
+    /// @param to The recipient of the tokens.
+    /// @param amount Minimum amount of `toTokenAddress` tokens to deposit or withdraw.
+    /// @param encodedBridgeData An abi-encoded `BridgeData` struct.
+    /// @return success The magic bytes if successful.
+    function bridgeTransferFrom(
+        address,
+        address from,
+        address to,
+        uint256 amount,
+        bytes calldata encodedBridgeData
+    )
+        external
+        returns (bytes4 success)
+    {
+        // Ensure that only the `ERC20BridgeProxy` can call this function.
+        require(
+            msg.sender == _getERC20BridgeProxyAddress(),
+            "DydxBridge/ONLY_CALLABLE_BY_ERC20_BRIDGE_PROXY"
+        );
+
+        // Decode bridge data.
+        (BridgeData memory bridgeData) = abi.decode(encodedBridgeData, (BridgeData));
+
+        // The dydx accounts are owned by the `from` address.
+        IDydx.AccountInfo[] memory accounts = _createAccounts(from, bridgeData);
+
+        // Create dydx actions to run on the dydx accounts.
+        IDydx.ActionArgs[] memory actions = _createActions(
+            from,
+            to,
+            amount,
+            bridgeData
+        );
+
+        // Run operation. This will revert on failure.
+        IDydx(_getDydxAddress()).operate(accounts, actions);
+        return BRIDGE_SUCCESS;
+    }
+
+    /// @dev Creates an array of accounts for dydx to operate on.
+    ///      All accounts must belong to the same owner.
+    /// @param accountOwner Owner of the dydx account.
+    /// @param bridgeData A `BridgeData` struct.
+    function _createAccounts(
+        address accountOwner,
+        BridgeData memory bridgeData
+    )
+        internal
+        returns (IDydx.AccountInfo[] memory accounts)
+    {
+        uint256[] memory accountNumbers = bridgeData.accountNumbers;
+        uint256 nAccounts = accountNumbers.length;
+        accounts = new IDydx.AccountInfo[](nAccounts);
+        for (uint256 i = 0; i < nAccounts; ++i) {
+            accounts[i] = IDydx.AccountInfo({
+                owner: accountOwner,
+                number: accountNumbers[i]
+            });
+        }
+    }
+
+    /// @dev Creates an array of actions to carry out on dydx.
+    /// @param depositFrom Deposit value from this address (owner of the dydx account).
+    /// @param withdrawTo Withdraw value to this address.
+    /// @param amount The amount of value available to operate on.
+    /// @param bridgeData A `BridgeData` struct.
+    function _createActions(
+        address depositFrom,
+        address withdrawTo,
+        uint256 amount,
+        BridgeData memory bridgeData
+    )
+        internal
+        returns (IDydx.ActionArgs[] memory actions)
+    {
+        BridgeAction[] memory bridgeActions = bridgeData.actions;
+        uint256 nBridgeActions = bridgeActions.length;
+        actions = new IDydx.ActionArgs[](nBridgeActions);
+        for (uint256 i = 0; i < nBridgeActions; ++i) {
+            // Cache current bridge action.
+            BridgeAction memory bridgeAction = bridgeActions[i];
+
+            // Scale amount, if conversion rate is set.
+            uint256 scaledAmount;
+            if (bridgeAction.conversionRateDenominator > 0) {
+                scaledAmount = LibMath.safeGetPartialAmountFloor(
+                    bridgeAction.conversionRateNumerator,
+                    bridgeAction.conversionRateDenominator,
+                    amount
+                );
+            } else {
+                scaledAmount = amount;
+            }
+
+            // Construct dydx action.
+            if (bridgeAction.actionType == BridgeActionType.Deposit) {
+                // Deposit tokens from the account owner into their dydx account.
+                actions[i] = _createDepositAction(
+                    depositFrom,
+                    scaledAmount,
+                    bridgeAction
+                );
+            } else if (bridgeAction.actionType == BridgeActionType.Withdraw) {
+                // Withdraw tokens from dydx to the `otherAccount`.
+                actions[i] = _createWithdrawAction(
+                    withdrawTo,
+                    scaledAmount,
+                    bridgeAction
+                );
+            } else {
+                // If all values in the `Action` enum are handled then this
+                // revert is unreachable: Solidity will revert when casting
+                // from `uint8` to `Action`.
+                revert("DydxBridge/UNRECOGNIZED_BRIDGE_ACTION");
+            }
+        }
+    }
+
+    /// @dev Returns a dydx `DepositAction`.
+    /// @param depositFrom Deposit tokens from this address who is also the account owner.
+    /// @param amount of tokens to deposit.
+    /// @param bridgeAction A `BridgeAction` struct.
+    /// @return depositAction The encoded dydx action.
+    function _createDepositAction(
+        address depositFrom,
+        uint256 amount,
+        BridgeAction memory bridgeAction
+    )
+        internal
+        pure
+        returns (
+            IDydx.ActionArgs memory depositAction
+        )
+    {
+        // Create dydx amount.
+        IDydx.AssetAmount memory dydxAmount = IDydx.AssetAmount({
+            sign: true,                                 // true if positive.
+            denomination: IDydx.AssetDenomination.Wei,  // Wei => actual token amount held in account.
+            ref: IDydx.AssetReference.Delta,                // Delta => a relative amount.
+            value: amount                               // amount to deposit.
+        });
+
+        // Create dydx deposit action.
+        depositAction = IDydx.ActionArgs({
+            actionType: IDydx.ActionType.Deposit,           // deposit tokens.
+            amount: dydxAmount,                             // amount to deposit.
+            accountId: bridgeAction.accountId,              // index in the `accounts` when calling `operate`.
+            primaryMarketId: bridgeAction.marketId,         // indicates which token to deposit.
+            otherAddress: depositFrom,                      // deposit from the account owner.
+            // unused parameters
+            secondaryMarketId: 0,
+            otherAccountId: 0,
+            data: hex''
+        });
+    }
+
+    /// @dev Returns a dydx `WithdrawAction`.
+    /// @param withdrawTo Withdraw tokens to this address.
+    /// @param amount of tokens to withdraw.
+    /// @param bridgeAction A `BridgeAction` struct.
+    /// @return withdrawAction The encoded dydx action.
+    function _createWithdrawAction(
+        address withdrawTo,
+        uint256 amount,
+        BridgeAction memory bridgeAction
+    )
+        internal
+        pure
+        returns (
+            IDydx.ActionArgs memory withdrawAction
+        )
+    {
+        // Create dydx amount.
+        IDydx.AssetAmount memory amountToWithdraw = IDydx.AssetAmount({
+            sign: false,                                    // false if negative.
+            denomination: IDydx.AssetDenomination.Wei,      // Wei => actual token amount held in account.
+            ref: IDydx.AssetReference.Delta,                // Delta => a relative amount.
+            value: amount                                   // amount to withdraw.
+        });
+
+        // Create withdraw action.
+        withdrawAction = IDydx.ActionArgs({
+            actionType: IDydx.ActionType.Withdraw,          // withdraw tokens.
+            amount: amountToWithdraw,                       // amount to withdraw.
+            accountId: bridgeAction.accountId,              // index in the `accounts` when calling `operate`.
+            primaryMarketId: bridgeAction.marketId,         // indicates which token to withdraw.
+            otherAddress: withdrawTo,                       // withdraw tokens to this address.
+            // unused parameters
+            secondaryMarketId: 0,
+            otherAccountId: 0,
+            data: hex''
+        });
+    }
+}

contracts/asset-proxy/contracts/src/bridges/Eth2DaiBridge.sol

@@ -20,19 +20,19 @@ pragma solidity ^0.5.9;
 pragma experimental ABIEncoderV2;
 
 import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
+import "@0x/contracts-erc20/contracts/src/LibERC20Token.sol";
+import "@0x/contracts-exchange-libs/contracts/src/IWallet.sol";
+import "@0x/contracts-utils/contracts/src/DeploymentConstants.sol";
 import "../interfaces/IERC20Bridge.sol";
 import "../interfaces/IEth2Dai.sol";
-import "../interfaces/IWallet.sol";
 
 
 // solhint-disable space-after-comma
 contract Eth2DaiBridge is
     IERC20Bridge,
-    IWallet
+    IWallet,
+    DeploymentConstants
 {
-    /* Mainnet addresses */
-    address constant public ETH2DAI_ADDRESS = 0x39755357759cE0d7f32dC8dC45414CCa409AE24e;
-
     /// @dev Callback for `IERC20Bridge`. Tries to buy `amount` of
     ///      `toTokenAddress` tokens by selling the entirety of the opposing asset
     ///      (DAI or WETH) to the Eth2Dai contract, then transfers the bought
@@ -42,7 +42,7 @@ contract Eth2DaiBridge is
     /// @param amount Minimum amount of `toTokenAddress` tokens to buy.
     /// @param bridgeData The abi-encoeded "from" token address.
     /// @return success The magic bytes if successful.
-    function withdrawTo(
+    function bridgeTransferFrom(
         address toTokenAddress,
         address /* from */,
         address to,
@@ -55,19 +55,19 @@ contract Eth2DaiBridge is
         // Decode the bridge data to get the `fromTokenAddress`.
         (address fromTokenAddress) = abi.decode(bridgeData, (address));
 
-        IEth2Dai exchange = _getEth2DaiContract();
+        IEth2Dai exchange = IEth2Dai(_getEth2DaiAddress());
         // Grant an allowance to the exchange to spend `fromTokenAddress` token.
-        IERC20Token(fromTokenAddress).approve(address(exchange), uint256(-1));
+        LibERC20Token.approve(fromTokenAddress, address(exchange), uint256(-1));
 
         // Try to sell all of this contract's `fromTokenAddress` token balance.
-        uint256 boughtAmount = _getEth2DaiContract().sellAllAmount(
-            address(fromTokenAddress),
+        uint256 boughtAmount = exchange.sellAllAmount(
+            fromTokenAddress,
             IERC20Token(fromTokenAddress).balanceOf(address(this)),
             toTokenAddress,
             amount
         );
         // Transfer the converted `toToken`s to `to`.
-        _transferERC20Token(toTokenAddress, to, boughtAmount);
+        LibERC20Token.transfer(toTokenAddress, to, boughtAmount);
         return BRIDGE_SUCCESS;
     }
 
@@ -84,59 +84,4 @@ contract Eth2DaiBridge is
     {
         return LEGACY_WALLET_MAGIC_VALUE;
     }
-
-    /// @dev Overridable way to get the eth2dai contract.
-    /// @return exchange The Eth2Dai exchange contract.
-    function _getEth2DaiContract()
-        internal
-        view
-        returns (IEth2Dai exchange)
-    {
-        return IEth2Dai(ETH2DAI_ADDRESS);
-    }
-
-    /// @dev Permissively transfers an ERC20 token that may not adhere to
-    ///      specs.
-    /// @param tokenAddress The token contract address.
-    /// @param to The token recipient.
-    /// @param amount The amount of tokens to transfer.
-    function _transferERC20Token(
-        address tokenAddress,
-        address to,
-        uint256 amount
-    )
-        private
-    {
-        // Transfer tokens.
-        // We do a raw call so we can check the success separate
-        // from the return data.
-        (bool didSucceed, bytes memory returnData) = tokenAddress.call(
-            abi.encodeWithSelector(
-                IERC20Token(0).transfer.selector,
-                to,
-                amount
-            )
-        );
-        if (!didSucceed) {
-            assembly { revert(add(returnData, 0x20), mload(returnData)) }
-        }
-
-        // Check return data.
-        // If there is no return data, we assume the token incorrectly
-        // does not return a bool. In this case we expect it to revert
-        // on failure, which was handled above.
-        // If the token does return data, we require that it is a single
-        // value that evaluates to true.
-        assembly {
-            if returndatasize {
-                didSucceed := 0
-                if eq(returndatasize, 32) {
-                    // First 64 bytes of memory are reserved scratch space
-                    returndatacopy(0, 0, 32)
-                    didSucceed := mload(0)
-                }
-            }
-        }
-        require(didSucceed, "ERC20_TRANSFER_FAILED");
-    }
 }

contracts/asset-proxy/contracts/src/bridges/KyberBridge.sol

@@ -0,0 +1,162 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
+import "@0x/contracts-erc20/contracts/src/interfaces/IEtherToken.sol";
+import "@0x/contracts-erc20/contracts/src/LibERC20Token.sol";
+import "@0x/contracts-exchange-libs/contracts/src/IWallet.sol";
+import "@0x/contracts-utils/contracts/src/DeploymentConstants.sol";
+import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
+import "../interfaces/IERC20Bridge.sol";
+import "../interfaces/IKyberNetworkProxy.sol";
+
+
+// solhint-disable space-after-comma
+contract KyberBridge is
+    IERC20Bridge,
+    IWallet,
+    DeploymentConstants
+{
+    using LibSafeMath for uint256;
+
+    // @dev Structure used internally to get around stack limits.
+    struct TradeState {
+        IKyberNetworkProxy kyber;
+        IEtherToken weth;
+        address fromTokenAddress;
+        uint256 fromTokenBalance;
+        uint256 payableAmount;
+        uint256 conversionRate;
+    }
+
+    /// @dev Kyber ETH pseudo-address.
+    address constant public KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+    /// @dev `bridgeTransferFrom()` failure result.
+    bytes4 constant private BRIDGE_FAILED = 0x0;
+    /// @dev Precision of Kyber rates.
+    uint256 constant private KYBER_RATE_BASE = 10 ** 18;
+
+    // solhint-disable no-empty-blocks
+    /// @dev Payable fallback to receive ETH from Kyber.
+    function ()
+        external
+        payable
+    {}
+
+    /// @dev Callback for `IKyberBridge`. Tries to buy `amount` of
+    ///      `toTokenAddress` tokens by selling the entirety of the opposing asset
+    ///      to the `KyberNetworkProxy` contract, then transfers the bought
+    ///      tokens to `to`.
+    /// @param toTokenAddress The token to give to `to`.
+    /// @param to The recipient of the bought tokens.
+    /// @param amount Minimum amount of `toTokenAddress` tokens to buy.
+    /// @param bridgeData The abi-encoeded "from" token address.
+    /// @return success The magic bytes if successful.
+    function bridgeTransferFrom(
+        address toTokenAddress,
+        address /* from */,
+        address to,
+        uint256 amount,
+        bytes calldata bridgeData
+    )
+        external
+        returns (bytes4 success)
+    {
+        TradeState memory state;
+        state.kyber = IKyberNetworkProxy(_getKyberNetworkProxyAddress());
+        state.weth = IEtherToken(_getWethAddress());
+        // Decode the bridge data to get the `fromTokenAddress`.
+        (state.fromTokenAddress) = abi.decode(bridgeData, (address));
+        // Query the balance of "from" tokens.
+        state.fromTokenBalance = IERC20Token(state.fromTokenAddress).balanceOf(address(this));
+        if (state.fromTokenBalance == 0) {
+            // Return failure if no input tokens.
+            return BRIDGE_FAILED;
+        }
+        // Compute the conversion rate, expressed in 18 decimals.
+        // The sequential notation is to get around stack limits.
+        state.conversionRate = KYBER_RATE_BASE;
+        state.conversionRate = state.conversionRate.safeMul(amount);
+        state.conversionRate = state.conversionRate.safeMul(
+            10 ** uint256(LibERC20Token.decimals(state.fromTokenAddress))
+        );
+        state.conversionRate = state.conversionRate.safeDiv(state.fromTokenBalance);
+        state.conversionRate = state.conversionRate.safeDiv(
+            10 ** uint256(LibERC20Token.decimals(toTokenAddress))
+        );
+        if (state.fromTokenAddress == toTokenAddress) {
+            // Just transfer the tokens if they're the same.
+            LibERC20Token.transfer(state.fromTokenAddress, to, state.fromTokenBalance);
+            return BRIDGE_SUCCESS;
+        } else if (state.fromTokenAddress != address(state.weth)) {
+            // If the input token is not WETH, grant an allowance to the exchange
+            // to spend them.
+            LibERC20Token.approve(state.fromTokenAddress, address(state.kyber), uint256(-1));
+        } else {
+            // If the input token is WETH, unwrap it and attach it to the call.
+            state.fromTokenAddress = KYBER_ETH_ADDRESS;
+            state.payableAmount = state.fromTokenBalance;
+            state.weth.withdraw(state.fromTokenBalance);
+        }
+        bool isToTokenWeth = toTokenAddress == address(state.weth);
+
+        // Try to sell all of this contract's input token balance through
+        // `KyberNetworkProxy.trade()`.
+        uint256 boughtAmount = state.kyber.trade.value(state.payableAmount)(
+            // Input token.
+            state.fromTokenAddress,
+            // Sell amount.
+            state.fromTokenBalance,
+            // Output token.
+            isToTokenWeth ? KYBER_ETH_ADDRESS : toTokenAddress,
+            // Transfer to this contract if converting to ETH, otherwise
+            // transfer directly to the recipient.
+            isToTokenWeth ? address(uint160(address(this))) : address(uint160(to)),
+            // Buy as much as possible.
+            uint256(-1),
+            // Compute the minimum conversion rate, which is expressed in units with
+            // 18 decimal places.
+            state.conversionRate,
+            // No affiliate address.
+            address(0)
+        );
+        // Wrap ETH output and transfer to recipient.
+        if (isToTokenWeth) {
+            state.weth.deposit.value(boughtAmount)();
+            state.weth.transfer(to, boughtAmount);
+        }
+        return BRIDGE_SUCCESS;
+    }
+
+    /// @dev `SignatureType.Wallet` callback, so that this bridge can be the maker
+    ///      and sign for itself in orders. Always succeeds.
+    /// @return magicValue Magic success bytes, always.
+    function isValidSignature(
+        bytes32,
+        bytes calldata
+    )
+        external
+        view
+        returns (bytes4 magicValue)
+    {
+        return LEGACY_WALLET_MAGIC_VALUE;
+    }
+}

contracts/asset-proxy/contracts/src/bridges/UniswapBridge.sol

@@ -0,0 +1,200 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
+import "@0x/contracts-erc20/contracts/src/interfaces/IEtherToken.sol";
+import "@0x/contracts-erc20/contracts/src/LibERC20Token.sol";
+import "@0x/contracts-exchange-libs/contracts/src/IWallet.sol";
+import "@0x/contracts-utils/contracts/src/DeploymentConstants.sol";
+import "../interfaces/IUniswapExchangeFactory.sol";
+import "../interfaces/IUniswapExchange.sol";
+import "../interfaces/IERC20Bridge.sol";
+
+
+// solhint-disable space-after-comma
+// solhint-disable not-rely-on-time
+contract UniswapBridge is
+    IERC20Bridge,
+    IWallet,
+    DeploymentConstants
+{
+    // Struct to hold `bridgeTransferFrom()` local variables in memory and to avoid
+    // stack overflows.
+    struct WithdrawToState {
+        IUniswapExchange exchange;
+        uint256 fromTokenBalance;
+        IEtherToken weth;
+    }
+
+    // solhint-disable no-empty-blocks
+    /// @dev Payable fallback to receive ETH from uniswap.
+    function ()
+        external
+        payable
+    {}
+
+    /// @dev Callback for `IERC20Bridge`. Tries to buy `amount` of
+    ///      `toTokenAddress` tokens by selling the entirety of the `fromTokenAddress`
+    ///      token encoded in the bridge data.
+    /// @param toTokenAddress The token to buy and transfer to `to`.
+    /// @param to The recipient of the bought tokens.
+    /// @param amount Minimum amount of `toTokenAddress` tokens to buy.
+    /// @param bridgeData The abi-encoded "from" token address.
+    /// @return success The magic bytes if successful.
+    function bridgeTransferFrom(
+        address toTokenAddress,
+        address /* from */,
+        address to,
+        uint256 amount,
+        bytes calldata bridgeData
+    )
+        external
+        returns (bytes4 success)
+    {
+        // State memory object to avoid stack overflows.
+        WithdrawToState memory state;
+        // Decode the bridge data to get the `fromTokenAddress`.
+        (address fromTokenAddress) = abi.decode(bridgeData, (address));
+
+        // Just transfer the tokens if they're the same.
+        if (fromTokenAddress == toTokenAddress) {
+            LibERC20Token.transfer(fromTokenAddress, to, amount);
+            return BRIDGE_SUCCESS;
+        }
+
+        // Get the exchange for the token pair.
+        state.exchange = _getUniswapExchangeForTokenPair(
+            fromTokenAddress,
+            toTokenAddress
+        );
+        // Get our balance of `fromTokenAddress` token.
+        state.fromTokenBalance = IERC20Token(fromTokenAddress).balanceOf(address(this));
+        // Get the weth contract.
+        state.weth = IEtherToken(_getWethAddress());
+
+        // Convert from WETH to a token.
+        if (fromTokenAddress == address(state.weth)) {
+            // Unwrap the WETH.
+            state.weth.withdraw(state.fromTokenBalance);
+            // Buy as much of `toTokenAddress` token with ETH as possible and
+            // transfer it to `to`.
+            state.exchange.ethToTokenTransferInput.value(state.fromTokenBalance)(
+                // Minimum buy amount.
+                amount,
+                // Expires after this block.
+                block.timestamp,
+                // Recipient is `to`.
+                to
+            );
+
+        // Convert from a token to WETH.
+        } else if (toTokenAddress == address(state.weth)) {
+            // Grant the exchange an allowance.
+            _grantExchangeAllowance(state.exchange, fromTokenAddress);
+            // Buy as much ETH with `fromTokenAddress` token as possible.
+            uint256 ethBought = state.exchange.tokenToEthSwapInput(
+                // Sell all tokens we hold.
+                state.fromTokenBalance,
+                // Minimum buy amount.
+                amount,
+                // Expires after this block.
+                block.timestamp
+            );
+            // Wrap the ETH.
+            state.weth.deposit.value(ethBought)();
+            // Transfer the WETH to `to`.
+            IEtherToken(toTokenAddress).transfer(to, ethBought);
+
+        // Convert from one token to another.
+        } else {
+            // Grant the exchange an allowance.
+            _grantExchangeAllowance(state.exchange, fromTokenAddress);
+            // Buy as much `toTokenAddress` token with `fromTokenAddress` token
+            // and transfer it to `to`.
+            state.exchange.tokenToTokenTransferInput(
+                // Sell all tokens we hold.
+                state.fromTokenBalance,
+                // Minimum buy amount.
+                amount,
+                // Must buy at least 1 intermediate ETH.
+                1,
+                // Expires after this block.
+                block.timestamp,
+                // Recipient is `to`.
+                to,
+                // Convert to `toTokenAddress`.
+                toTokenAddress
+            );
+        }
+        return BRIDGE_SUCCESS;
+    }
+
+    /// @dev `SignatureType.Wallet` callback, so that this bridge can be the maker
+    ///      and sign for itself in orders. Always succeeds.
+    /// @return magicValue Success bytes, always.
+    function isValidSignature(
+        bytes32,
+        bytes calldata
+    )
+        external
+        view
+        returns (bytes4 magicValue)
+    {
+        return LEGACY_WALLET_MAGIC_VALUE;
+    }
+
+    /// @dev Grants an unlimited allowance to the exchange for its token
+    ///      on behalf of this contract.
+    /// @param exchange The Uniswap token exchange.
+    /// @param tokenAddress The token address for the exchange.
+    function _grantExchangeAllowance(IUniswapExchange exchange, address tokenAddress)
+        private
+    {
+        LibERC20Token.approve(tokenAddress, address(exchange), uint256(-1));
+    }
+
+    /// @dev Retrieves the uniswap exchange for a given token pair.
+    ///      In the case of a WETH-token exchange, this will be the non-WETH token.
+    ///      In th ecase of a token-token exchange, this will be the first token.
+    /// @param fromTokenAddress The address of the token we are converting from.
+    /// @param toTokenAddress The address of the token we are converting to.
+    /// @return exchange The uniswap exchange.
+    function _getUniswapExchangeForTokenPair(
+        address fromTokenAddress,
+        address toTokenAddress
+    )
+        private
+        view
+        returns (IUniswapExchange exchange)
+    {
+        address exchangeTokenAddress = fromTokenAddress;
+        // Whichever isn't WETH is the exchange token.
+        if (fromTokenAddress == _getWethAddress()) {
+            exchangeTokenAddress = toTokenAddress;
+        }
+        exchange = IUniswapExchange(
+            IUniswapExchangeFactory(_getUniswapExchangeFactoryAddress())
+            .getExchange(exchangeTokenAddress)
+        );
+        require(address(exchange) != address(0), "NO_UNISWAP_EXCHANGE_FOR_TOKEN");
+        return exchange;
+    }
+}

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

@@ -0,0 +1,66 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
+
+
+contract PotLike {
+    function chi() external returns (uint256);
+    function rho() external returns (uint256);
+    function drip() external returns (uint256);
+    function join(uint256) external;
+    function exit(uint256) external;
+}
+
+
+// The actual Chai contract can be found here: https://github.com/dapphub/chai
+contract IChai is
+    IERC20Token
+{
+    /// @dev Withdraws Dai owned by `src`
+    /// @param src Address that owns Dai.
+    /// @param wad Amount of Dai to withdraw.
+    function draw(
+        address src,
+        uint256 wad
+    )
+        external;
+
+    /// @dev Queries Dai balance of Chai holder.
+    /// @param usr Address of Chai holder.
+    /// @return Dai balance.
+    function dai(address usr)
+        external
+        returns (uint256);
+
+    /// @dev Queries the Pot contract used by the Chai contract.
+    function pot()
+        external
+        returns (PotLike);
+
+    /// @dev Deposits Dai in exchange for Chai
+    /// @param dst Address to receive Chai.
+    /// @param wad Amount of Dai to deposit.
+    function join(
+        address dst,
+        uint256 wad
+    )
+        external;
+}

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

@@ -0,0 +1,89 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
+
+
+interface IDydx {
+
+    /// @dev Represents the unique key that specifies an account
+    struct AccountInfo {
+        address owner;  // The address that owns the account
+        uint256 number; // A nonce that allows a single address to control many accounts
+    }
+
+    enum ActionType {
+        Deposit,   // supply tokens
+        Withdraw,  // borrow tokens
+        Transfer,  // transfer balance between accounts
+        Buy,       // buy an amount of some token (externally)
+        Sell,      // sell an amount of some token (externally)
+        Trade,     // trade tokens against another account
+        Liquidate, // liquidate an undercollateralized or expiring account
+        Vaporize,  // use excess tokens to zero-out a completely negative account
+        Call       // send arbitrary data to an address
+    }
+
+    /// @dev Arguments that are passed to Solo in an ordered list as part of a single operation.
+    /// Each ActionArgs has an actionType which specifies which action struct that this data will be
+    /// parsed into before being processed.
+    struct ActionArgs {
+        ActionType actionType;
+        uint256 accountId;
+        AssetAmount amount;
+        uint256 primaryMarketId;
+        uint256 secondaryMarketId;
+        address otherAddress;
+        uint256 otherAccountId;
+        bytes data;
+    }
+
+    enum AssetDenomination {
+        Wei, // the amount is denominated in wei
+        Par  // the amount is denominated in par
+    }
+
+    enum AssetReference {
+        Delta, // the amount is given as a delta from the current value
+        Target // the amount is given as an exact number to end up at
+    }
+
+    struct AssetAmount {
+        bool sign; // true if positive
+        AssetDenomination denomination;
+        AssetReference ref;
+        uint256 value;
+    }
+
+    /// @dev The main entry-point to Solo that allows users and contracts to manage accounts.
+    ///      Take one or more actions on one or more accounts. The msg.sender must be the owner or
+    ///      operator of all accounts except for those being liquidated, vaporized, or traded with.
+    ///      One call to operate() is considered a singular "operation". Account collateralization is
+    ///      ensured only after the completion of the entire operation.
+    /// @param  accounts  A list of all accounts that will be used in this operation. Cannot contain
+    ///                   duplicates. In each action, the relevant account will be referred-to by its
+    ///                   index in the list.
+    /// @param  actions   An ordered list of all actions that will be taken in this operation. The
+    ///                   actions will be processed in order.
+    function operate(
+        AccountInfo[] calldata accounts,
+        ActionArgs[] calldata actions
+    )
+        external;
+}

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

@@ -0,0 +1,42 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+
+interface IDydxBridge {
+
+    /// @dev This is the subset of `IDydx.ActionType` that are supported by the bridge.
+    enum BridgeActionType {
+        Deposit,                    // Deposit tokens into dydx account.
+        Withdraw                    // Withdraw tokens from dydx account.
+    }
+
+    struct BridgeAction {
+        BridgeActionType actionType;            // Action to run on dydx account.
+        uint256 accountId;                      // Index in `BridgeData.accountNumbers` for this action.
+        uint256 marketId;                       // Market to operate on.
+        uint256 conversionRateNumerator;        // Optional. If set, transfer amount is scaled by (conversionRateNumerator/conversionRateDenominator).
+        uint256 conversionRateDenominator;      // Optional. If set, transfer amount is scaled by (conversionRateNumerator/conversionRateDenominator).
+    }
+
+    struct BridgeData {
+        uint256[] accountNumbers;               // Account number used to identify the owner's specific account.
+        BridgeAction[] actions;                 // Actions to carry out on the owner's accounts.
+    }
+}

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

@@ -31,7 +31,7 @@ contract IERC20Bridge {
     /// @param amount Amount of asset to transfer.
     /// @param bridgeData Arbitrary asset data needed by the bridge contract.
     /// @return success The magic bytes `0x37708e9b` if successful.
-    function withdrawTo(
+    function bridgeTransferFrom(
         address tokenAddress,
         address from,
         address to,

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

@@ -0,0 +1,46 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+
+interface IKyberNetworkProxy {
+
+    /// @dev Sells `sellTokenAddress` tokens for `buyTokenAddress` tokens.
+    /// @param sellTokenAddress Token to sell.
+    /// @param sellAmount Amount of tokens to sell.
+    /// @param buyTokenAddress Token to buy.
+    /// @param recipientAddress Address to send bought tokens to.
+    /// @param maxBuyTokenAmount A limit on the amount of tokens to buy.
+    /// @param minConversionRate The minimal conversion rate. If actual rate
+    ///        is lower, trade is canceled.
+    /// @param walletId The wallet ID to send part of the fees
+    /// @return boughtAmount Amount of tokens bought.
+    function trade(
+        address sellTokenAddress,
+        uint256 sellAmount,
+        address buyTokenAddress,
+        address payable recipientAddress,
+        uint256 maxBuyTokenAmount,
+        uint256 minConversionRate,
+        address walletId
+    )
+        external
+        payable
+        returns(uint256 boughtAmount);
+}

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

@@ -0,0 +1,70 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+
+interface IUniswapExchange {
+
+    /// @dev Buys at least `minTokensBought` tokens with ETH and transfer them
+    ///      to `recipient`.
+    /// @param minTokensBought The minimum number of tokens to buy.
+    /// @param deadline Time when this order expires.
+    /// @param recipient Who to transfer the tokens to.
+    /// @return tokensBought Amount of tokens bought.
+    function ethToTokenTransferInput(
+        uint256 minTokensBought,
+        uint256 deadline,
+        address recipient
+    )
+        external
+        payable
+        returns (uint256 tokensBought);
+
+    /// @dev Buys at least `minEthBought` ETH with tokens.
+    /// @param tokensSold Amount of tokens to sell.
+    /// @param minEthBought The minimum amount of ETH to buy.
+    /// @param deadline Time when this order expires.
+    /// @return ethBought Amount of tokens bought.
+    function tokenToEthSwapInput(
+        uint256 tokensSold,
+        uint256 minEthBought,
+        uint256 deadline
+    )
+        external
+        returns (uint256 ethBought);
+
+    /// @dev Buys at least `minTokensBought` tokens with the exchange token
+    ///      and transfer them to `recipient`.
+    /// @param minTokensBought The minimum number of tokens to buy.
+    /// @param minEthBought The minimum amount of intermediate ETH to buy.
+    /// @param deadline Time when this order expires.
+    /// @param recipient Who to transfer the tokens to.
+    /// @param toTokenAddress The token being bought.
+    /// @return tokensBought Amount of tokens bought.
+    function tokenToTokenTransferInput(
+        uint256 tokensSold,
+        uint256 minTokensBought,
+        uint256 minEthBought,
+        uint256 deadline,
+        address recipient,
+        address toTokenAddress
+    )
+        external
+        returns (uint256 tokensBought);
+}

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

@@ -0,0 +1,32 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+import "./IUniswapExchange.sol";
+
+
+interface IUniswapExchangeFactory {
+
+    /// @dev Get the exchange for a token.
+    /// @param tokenAddress The address of the token contract.
+    function getExchange(address tokenAddress)
+        external
+        view
+        returns (address);
+}

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

@@ -0,0 +1,80 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
+
+import "../src/bridges/ChaiBridge.sol";
+import "@0x/contracts-erc20/contracts/src/ERC20Token.sol";
+
+
+contract TestChaiDai is
+    ERC20Token
+{
+    address private constant ALWAYS_REVERT_ADDRESS = address(1);
+
+    function draw(
+        address from,
+        uint256 amount
+    )
+        external
+    {
+        if (from == ALWAYS_REVERT_ADDRESS) {
+            revert();
+        }
+        balances[msg.sender] += amount;
+    }
+}
+
+
+contract TestChaiBridge is
+    ChaiBridge
+{
+    address public testChaiDai;
+    address private constant ALWAYS_REVERT_ADDRESS = address(1);
+
+    constructor()
+        public
+    {
+        testChaiDai = address(new TestChaiDai());
+    }
+
+    function _getDaiAddress()
+        internal
+        view
+        returns (address)
+    {
+        return testChaiDai;
+    }
+
+    function _getChaiAddress()
+        internal
+        view
+        returns (address)
+    {
+        return testChaiDai;
+    }
+
+    function _getERC20BridgeProxyAddress()
+        internal
+        view
+        returns (address)
+    {
+        return msg.sender == ALWAYS_REVERT_ADDRESS ? address(0) : msg.sender;
+    }
+}

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

@@ -0,0 +1,191 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
+import "../src/bridges/DydxBridge.sol";
+
+
+contract TestDydxBridgeToken {
+
+    uint256 private constant INIT_HOLDER_BALANCE = 10 * 10**18; // 10 tokens
+    mapping (address => uint256) private _balances;
+
+    /// @dev Sets initial balance of token holders.
+    constructor(address[] memory holders)
+        public
+    {
+        for (uint256 i = 0; i != holders.length; ++i) {
+            _balances[holders[i]] = INIT_HOLDER_BALANCE;
+        }
+        _balances[msg.sender] = INIT_HOLDER_BALANCE;
+    }
+
+    /// @dev Basic transferFrom implementation.
+    function transferFrom(address from, address to, uint256 amount)
+        external
+        returns (bool)
+    {
+        if (_balances[from] < amount || _balances[to] + amount < _balances[to]) {
+            return false;
+        }
+        _balances[from] -= amount;
+        _balances[to] += amount;
+        return true;
+    }
+
+    /// @dev Returns balance of `holder`.
+    function balanceOf(address holder)
+        external
+        view
+        returns (uint256)
+    {
+        return _balances[holder];
+    }
+}
+
+
+// solhint-disable space-after-comma
+contract TestDydxBridge is
+    IDydx,
+    DydxBridge
+{
+
+    address private constant ALWAYS_REVERT_ADDRESS = address(1);
+    address private _testTokenAddress;
+    bool private _shouldRevertOnOperate;
+
+    event OperateAccount(
+        address owner,
+        uint256 number
+    );
+
+    event OperateAction(
+        ActionType actionType,
+        uint256 accountId,
+        bool amountSign,
+        AssetDenomination amountDenomination,
+        AssetReference amountRef,
+        uint256 amountValue,
+        uint256 primaryMarketId,
+        uint256 secondaryMarketId,
+        address otherAddress,
+        uint256 otherAccountId,
+        bytes data
+    );
+
+    constructor(address[] memory holders)
+        public
+    {
+        // Deploy a test token. This represents the asset being deposited/withdrawn from dydx.
+        _testTokenAddress = address(new TestDydxBridgeToken(holders));
+    }
+
+    /// @dev Simulates `operate` in dydx contract.
+    ///      Emits events so that arguments can be validated client-side.
+    function operate(
+        AccountInfo[] calldata accounts,
+        ActionArgs[] calldata actions
+    )
+        external
+    {
+        if (_shouldRevertOnOperate) {
+            revert("TestDydxBridge/SHOULD_REVERT_ON_OPERATE");
+        }
+
+        for (uint i = 0; i < accounts.length; ++i) {
+            emit OperateAccount(
+                accounts[i].owner,
+                accounts[i].number
+            );
+        }
+
+        for (uint i = 0; i < actions.length; ++i) {
+            emit OperateAction(
+                actions[i].actionType,
+                actions[i].accountId,
+                actions[i].amount.sign,
+                actions[i].amount.denomination,
+                actions[i].amount.ref,
+                actions[i].amount.value,
+                actions[i].primaryMarketId,
+                actions[i].secondaryMarketId,
+                actions[i].otherAddress,
+                actions[i].otherAccountId,
+                actions[i].data
+            );
+
+            if (actions[i].actionType == IDydx.ActionType.Withdraw) {
+                require(
+                    IERC20Token(_testTokenAddress).transferFrom(
+                        address(this),
+                        actions[i].otherAddress,
+                        actions[i].amount.value
+                    ),
+                    "TestDydxBridge/WITHDRAW_FAILED"
+                );
+            } else if (actions[i].actionType == IDydx.ActionType.Deposit) {
+                require(
+                    IERC20Token(_testTokenAddress).transferFrom(
+                        actions[i].otherAddress,
+                        address(this),
+                        actions[i].amount.value
+                    ),
+                    "TestDydxBridge/DEPOSIT_FAILED"
+                );
+            } else {
+                revert("TestDydxBridge/UNSUPPORTED_ACTION");
+            }
+        }
+    }
+
+    /// @dev If `true` then subsequent calls to `operate` will revert.
+    function setRevertOnOperate(bool shouldRevert)
+        external
+    {
+        _shouldRevertOnOperate = shouldRevert;
+    }
+
+    /// @dev Returns test token.
+    function getTestToken()
+        external
+        returns (address)
+    {
+        return _testTokenAddress;
+    }
+
+    /// @dev overrides `_getDydxAddress()` from `DeploymentConstants` to return this address.
+    function _getDydxAddress()
+        internal
+        view
+        returns (address)
+    {
+        return address(this);
+    }
+
+    /// @dev overrides `_getERC20BridgeProxyAddress()` from `DeploymentConstants` for testing.
+    function _getERC20BridgeProxyAddress()
+        internal
+        view
+        returns (address)
+    {
+        return msg.sender == ALWAYS_REVERT_ADDRESS ? address(0) : msg.sender;
+    }
+}

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

@@ -72,7 +72,7 @@ contract TestERC20Bridge is
         testToken.setBalance(owner, balance);
     }
 
-    function withdrawTo(
+    function bridgeTransferFrom(
         address tokenAddress,
         address from,
         address to,

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

@@ -192,11 +192,11 @@ contract TestEth2DaiBridge is
     }
 
     // @dev This contract will double as the Eth2Dai contract.
-    function _getEth2DaiContract()
+    function _getEth2DaiAddress()
         internal
         view
-        returns (IEth2Dai)
+        returns (address)
     {
-        return IEth2Dai(address(this));
+        return address(this);
     }
 }

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

@@ -0,0 +1,324 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
+import "../src/bridges/KyberBridge.sol";
+import "../src/interfaces/IKyberNetworkProxy.sol";
+
+
+// solhint-disable no-simple-event-func-name
+interface ITestContract {
+
+    function wethWithdraw(
+        address payable ownerAddress,
+        uint256 amount
+    )
+        external;
+
+    function wethDeposit(
+        address ownerAddress
+    )
+        external
+        payable;
+
+    function tokenTransfer(
+        address ownerAddress,
+        address recipientAddress,
+        uint256 amount
+    )
+        external
+        returns (bool success);
+
+    function tokenApprove(
+        address ownerAddress,
+        address spenderAddress,
+        uint256 allowance
+    )
+        external
+        returns (bool success);
+
+    function tokenBalanceOf(
+        address ownerAddress
+    )
+        external
+        view
+        returns (uint256 balance);
+}
+
+
+/// @dev A minimalist ERC20/WETH token.
+contract TestToken {
+
+    uint8 public decimals;
+    ITestContract private _testContract;
+
+    constructor(uint8 decimals_) public {
+        decimals = decimals_;
+        _testContract = ITestContract(msg.sender);
+    }
+
+    function approve(address spender, uint256 allowance)
+        external
+        returns (bool)
+    {
+        return _testContract.tokenApprove(
+            msg.sender,
+            spender,
+            allowance
+        );
+    }
+
+    function transfer(address recipient, uint256 amount)
+        external
+        returns (bool)
+    {
+        return _testContract.tokenTransfer(
+            msg.sender,
+            recipient,
+            amount
+        );
+    }
+
+    function withdraw(uint256 amount)
+        external
+    {
+        return _testContract.wethWithdraw(msg.sender, amount);
+    }
+
+    function deposit()
+        external
+        payable
+    {
+        return _testContract.wethDeposit.value(msg.value)(msg.sender);
+    }
+
+    function balanceOf(address owner)
+        external
+        view
+        returns (uint256)
+    {
+        return _testContract.tokenBalanceOf(owner);
+    }
+}
+
+
+/// @dev KyberBridge overridden to mock tokens and implement IKyberBridge.
+contract TestKyberBridge is
+    KyberBridge,
+    ITestContract,
+    IKyberNetworkProxy
+{
+    event KyberBridgeTrade(
+        uint256 msgValue,
+        address sellTokenAddress,
+        uint256 sellAmount,
+        address buyTokenAddress,
+        address payable recipientAddress,
+        uint256 maxBuyTokenAmount,
+        uint256 minConversionRate,
+        address walletId
+    );
+
+    event KyberBridgeWethWithdraw(
+        address ownerAddress,
+        uint256 amount
+    );
+
+    event KyberBridgeWethDeposit(
+        uint256 msgValue,
+        address ownerAddress,
+        uint256 amount
+    );
+
+    event KyberBridgeTokenApprove(
+        address tokenAddress,
+        address ownerAddress,
+        address spenderAddress,
+        uint256 allowance
+    );
+
+    event KyberBridgeTokenTransfer(
+        address tokenAddress,
+        address ownerAddress,
+        address recipientAddress,
+        uint256 amount
+    );
+
+    IEtherToken public weth;
+    mapping (address => mapping (address => uint256)) private _tokenBalances;
+    uint256 private _nextFillAmount;
+
+    constructor() public {
+        weth = IEtherToken(address(new TestToken(18)));
+    }
+
+    /// @dev Implementation of `IKyberNetworkProxy.trade()`
+    function trade(
+        address sellTokenAddress,
+        uint256 sellAmount,
+        address buyTokenAddress,
+        address payable recipientAddress,
+        uint256 maxBuyTokenAmount,
+        uint256 minConversionRate,
+        address walletId
+    )
+        external
+        payable
+        returns(uint256 boughtAmount)
+    {
+        emit KyberBridgeTrade(
+            msg.value,
+            sellTokenAddress,
+            sellAmount,
+            buyTokenAddress,
+            recipientAddress,
+            maxBuyTokenAmount,
+            minConversionRate,
+            walletId
+        );
+        return _nextFillAmount;
+    }
+
+    function createToken(uint8 decimals)
+        external
+        returns (address tokenAddress)
+    {
+        return address(new TestToken(decimals));
+    }
+
+    function setNextFillAmount(uint256 amount)
+        external
+        payable
+    {
+        if (msg.value != 0) {
+            require(amount == msg.value, "VALUE_AMOUNT_MISMATCH");
+            grantTokensTo(address(weth), address(this), msg.value);
+        }
+        _nextFillAmount = amount;
+    }
+
+    function wethDeposit(
+        address ownerAddress
+    )
+        external
+        payable
+    {
+        require(msg.sender == address(weth), "ONLY_WETH");
+        grantTokensTo(address(weth), ownerAddress, msg.value);
+        emit KyberBridgeWethDeposit(
+            msg.value,
+            ownerAddress,
+            msg.value
+        );
+    }
+
+    function wethWithdraw(
+        address payable ownerAddress,
+        uint256 amount
+    )
+        external
+    {
+        require(msg.sender == address(weth), "ONLY_WETH");
+        _tokenBalances[address(weth)][ownerAddress] -= amount;
+        ownerAddress.transfer(amount);
+        emit KyberBridgeWethWithdraw(
+            ownerAddress,
+            amount
+        );
+    }
+
+    function tokenApprove(
+        address ownerAddress,
+        address spenderAddress,
+        uint256 allowance
+    )
+        external
+        returns (bool success)
+    {
+        emit KyberBridgeTokenApprove(
+            msg.sender,
+            ownerAddress,
+            spenderAddress,
+            allowance
+        );
+        return true;
+    }
+
+    function tokenTransfer(
+        address ownerAddress,
+        address recipientAddress,
+        uint256 amount
+    )
+        external
+        returns (bool success)
+    {
+        _tokenBalances[msg.sender][ownerAddress] -= amount;
+        _tokenBalances[msg.sender][recipientAddress] += amount;
+        emit KyberBridgeTokenTransfer(
+            msg.sender,
+            ownerAddress,
+            recipientAddress,
+            amount
+        );
+        return true;
+    }
+
+    function tokenBalanceOf(
+        address ownerAddress
+    )
+        external
+        view
+        returns (uint256 balance)
+    {
+        return _tokenBalances[msg.sender][ownerAddress];
+    }
+
+    function grantTokensTo(address tokenAddress, address ownerAddress, uint256 amount)
+        public
+        payable
+    {
+        _tokenBalances[tokenAddress][ownerAddress] += amount;
+        if (tokenAddress != address(weth)) {
+            // Send back ether if not WETH.
+            msg.sender.transfer(msg.value);
+        } else {
+            require(msg.value == amount, "VALUE_AMOUNT_MISMATCH");
+        }
+    }
+
+    // @dev overridden to point to this contract.
+    function _getKyberNetworkProxyAddress()
+        internal
+        view
+        returns (address)
+    {
+        return address(this);
+    }
+
+    // @dev overridden to point to test WETH.
+    function _getWethAddress()
+        internal
+        view
+        returns (address)
+    {
+        return address(weth);
+    }
+}

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

@@ -0,0 +1,432 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
+import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
+import "../src/bridges/UniswapBridge.sol";
+import "../src/interfaces/IUniswapExchangeFactory.sol";
+import "../src/interfaces/IUniswapExchange.sol";
+
+
+// solhint-disable no-simple-event-func-name
+contract TestEventsRaiser {
+
+    event TokenTransfer(
+        address token,
+        address from,
+        address to,
+        uint256 amount
+    );
+
+    event TokenApprove(
+        address spender,
+        uint256 allowance
+    );
+
+    event WethDeposit(
+        uint256 amount
+    );
+
+    event WethWithdraw(
+        uint256 amount
+    );
+
+    event EthToTokenTransferInput(
+        address exchange,
+        uint256 minTokensBought,
+        uint256 deadline,
+        address recipient
+    );
+
+    event TokenToEthSwapInput(
+        address exchange,
+        uint256 tokensSold,
+        uint256 minEthBought,
+        uint256 deadline
+    );
+
+    event TokenToTokenTransferInput(
+        address exchange,
+        uint256 tokensSold,
+        uint256 minTokensBought,
+        uint256 minEthBought,
+        uint256 deadline,
+        address recipient,
+        address toTokenAddress
+    );
+
+    function raiseEthToTokenTransferInput(
+        uint256 minTokensBought,
+        uint256 deadline,
+        address recipient
+    )
+        external
+    {
+        emit EthToTokenTransferInput(
+            msg.sender,
+            minTokensBought,
+            deadline,
+            recipient
+        );
+    }
+
+    function raiseTokenToEthSwapInput(
+        uint256 tokensSold,
+        uint256 minEthBought,
+        uint256 deadline
+    )
+        external
+    {
+        emit TokenToEthSwapInput(
+            msg.sender,
+            tokensSold,
+            minEthBought,
+            deadline
+        );
+    }
+
+    function raiseTokenToTokenTransferInput(
+        uint256 tokensSold,
+        uint256 minTokensBought,
+        uint256 minEthBought,
+        uint256 deadline,
+        address recipient,
+        address toTokenAddress
+    )
+        external
+    {
+        emit TokenToTokenTransferInput(
+            msg.sender,
+            tokensSold,
+            minTokensBought,
+            minEthBought,
+            deadline,
+            recipient,
+            toTokenAddress
+        );
+    }
+
+    function raiseTokenTransfer(
+        address from,
+        address to,
+        uint256 amount
+    )
+        external
+    {
+        emit TokenTransfer(
+            msg.sender,
+            from,
+            to,
+            amount
+        );
+    }
+
+    function raiseTokenApprove(address spender, uint256 allowance)
+        external
+    {
+        emit TokenApprove(spender, allowance);
+    }
+
+    function raiseWethDeposit(uint256 amount)
+        external
+    {
+        emit WethDeposit(amount);
+    }
+
+    function raiseWethWithdraw(uint256 amount)
+        external
+    {
+        emit WethWithdraw(amount);
+    }
+}
+
+
+/// @dev A minimalist ERC20/WETH token.
+contract TestToken {
+
+    using LibSafeMath for uint256;
+
+    mapping (address => uint256) public balances;
+    string private _nextRevertReason;
+
+    /// @dev Set the balance for `owner`.
+    function setBalance(address owner)
+        external
+        payable
+    {
+        balances[owner] = msg.value;
+    }
+
+    /// @dev Set the revert reason for `transfer()`,
+    ///      `deposit()`, and `withdraw()`.
+    function setRevertReason(string calldata reason)
+        external
+    {
+        _nextRevertReason = reason;
+    }
+
+    /// @dev Just calls `raiseTokenTransfer()` on the caller.
+    function transfer(address to, uint256 amount)
+        external
+        returns (bool)
+    {
+        _revertIfReasonExists();
+        TestEventsRaiser(msg.sender).raiseTokenTransfer(msg.sender, to, amount);
+        return true;
+    }
+
+    /// @dev Just calls `raiseTokenApprove()` on the caller.
+    function approve(address spender, uint256 allowance)
+        external
+        returns (bool)
+    {
+        TestEventsRaiser(msg.sender).raiseTokenApprove(spender, allowance);
+        return true;
+    }
+
+    /// @dev `IWETH.deposit()` that increases balances and calls
+    ///     `raiseWethDeposit()` on the caller.
+    function deposit()
+        external
+        payable
+    {
+        _revertIfReasonExists();
+        balances[msg.sender] += balances[msg.sender].safeAdd(msg.value);
+        TestEventsRaiser(msg.sender).raiseWethDeposit(msg.value);
+    }
+
+    /// @dev `IWETH.withdraw()` that just reduces balances and calls
+    ///       `raiseWethWithdraw()` on the caller.
+    function withdraw(uint256 amount)
+        external
+    {
+        _revertIfReasonExists();
+        balances[msg.sender] = balances[msg.sender].safeSub(amount);
+        msg.sender.transfer(amount);
+        TestEventsRaiser(msg.sender).raiseWethWithdraw(amount);
+    }
+
+    /// @dev Retrieve the balance for `owner`.
+    function balanceOf(address owner)
+        external
+        view
+        returns (uint256)
+    {
+        return balances[owner];
+    }
+
+    function _revertIfReasonExists()
+        private
+        view
+    {
+        if (bytes(_nextRevertReason).length != 0) {
+            revert(_nextRevertReason);
+        }
+    }
+}
+
+
+contract TestExchange is
+    IUniswapExchange
+{
+    address public tokenAddress;
+    string private _nextRevertReason;
+
+    constructor(address _tokenAddress) public {
+        tokenAddress = _tokenAddress;
+    }
+
+    function setFillBehavior(
+        string calldata revertReason
+    )
+        external
+        payable
+    {
+        _nextRevertReason = revertReason;
+    }
+
+    function ethToTokenTransferInput(
+        uint256 minTokensBought,
+        uint256 deadline,
+        address recipient
+    )
+        external
+        payable
+        returns (uint256 tokensBought)
+    {
+        TestEventsRaiser(msg.sender).raiseEthToTokenTransferInput(
+            minTokensBought,
+            deadline,
+            recipient
+        );
+        _revertIfReasonExists();
+        return address(this).balance;
+    }
+
+    function tokenToEthSwapInput(
+        uint256 tokensSold,
+        uint256 minEthBought,
+        uint256 deadline
+    )
+        external
+        returns (uint256 ethBought)
+    {
+        TestEventsRaiser(msg.sender).raiseTokenToEthSwapInput(
+            tokensSold,
+            minEthBought,
+            deadline
+        );
+        _revertIfReasonExists();
+        uint256 fillAmount = address(this).balance;
+        msg.sender.transfer(fillAmount);
+        return fillAmount;
+    }
+
+    function tokenToTokenTransferInput(
+        uint256 tokensSold,
+        uint256 minTokensBought,
+        uint256 minEthBought,
+        uint256 deadline,
+        address recipient,
+        address toTokenAddress
+    )
+        external
+        returns (uint256 tokensBought)
+    {
+        TestEventsRaiser(msg.sender).raiseTokenToTokenTransferInput(
+            tokensSold,
+            minTokensBought,
+            minEthBought,
+            deadline,
+            recipient,
+            toTokenAddress
+        );
+        _revertIfReasonExists();
+        return address(this).balance;
+    }
+
+    function toTokenAddress()
+        external
+        view
+        returns (address _tokenAddress)
+    {
+        return tokenAddress;
+    }
+
+    function _revertIfReasonExists()
+        private
+        view
+    {
+        if (bytes(_nextRevertReason).length != 0) {
+            revert(_nextRevertReason);
+        }
+    }
+}
+
+
+/// @dev UniswapBridge overridden to mock tokens and implement IUniswapExchangeFactory.
+contract TestUniswapBridge is
+    IUniswapExchangeFactory,
+    TestEventsRaiser,
+    UniswapBridge
+{
+    TestToken public wethToken;
+    // Token address to TestToken instance.
+    mapping (address => TestToken) private _testTokens;
+    // Token address to TestExchange instance.
+    mapping (address => TestExchange) private _testExchanges;
+
+    constructor() public {
+        wethToken = new TestToken();
+        _testTokens[address(wethToken)] = wethToken;
+    }
+
+    /// @dev Sets the balance of this contract for an existing token.
+    ///      The wei attached will be the balance.
+    function setTokenBalance(address tokenAddress)
+        external
+        payable
+    {
+        TestToken token = _testTokens[tokenAddress];
+        token.deposit.value(msg.value)();
+    }
+
+    /// @dev Sets the revert reason for an existing token.
+    function setTokenRevertReason(address tokenAddress, string calldata revertReason)
+        external
+    {
+        TestToken token = _testTokens[tokenAddress];
+        token.setRevertReason(revertReason);
+    }
+
+    /// @dev Create a token and exchange (if they don't exist) for a new token
+    ///      and sets the exchange revert and fill behavior. The wei attached
+    ///      will be the fill amount for the exchange.
+    /// @param tokenAddress The token address. If zero, one will be created.
+    /// @param revertReason The revert reason for exchange operations.
+    function createTokenAndExchange(
+        address tokenAddress,
+        string calldata revertReason
+    )
+        external
+        payable
+        returns (TestToken token, TestExchange exchange)
+    {
+        token = TestToken(tokenAddress);
+        if (tokenAddress == address(0)) {
+            token = new TestToken();
+        }
+        _testTokens[address(token)] = token;
+        exchange = _testExchanges[address(token)];
+        if (address(exchange) == address(0)) {
+            _testExchanges[address(token)] = exchange = new TestExchange(address(token));
+        }
+        exchange.setFillBehavior.value(msg.value)(revertReason);
+        return (token, exchange);
+    }
+
+    /// @dev `IUniswapExchangeFactory.getExchange`
+    function getExchange(address tokenAddress)
+        external
+        view
+        returns (address)
+    {
+        return address(_testExchanges[tokenAddress]);
+    }
+
+    // @dev Use `wethToken`.
+    function _getWethAddress()
+        internal
+        view
+        returns (address)
+    {
+        return address(wethToken);
+    }
+
+    // @dev This contract will double as the Uniswap contract.
+    function _getUniswapExchangeFactoryAddress()
+        internal
+        view
+        returns (address)
+    {
+        return address(this);
+    }
+}

contracts/asset-proxy/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-asset-proxy",
-    "version": "2.3.0-beta.0",
+    "version": "3.1.1",
     "engines": {
         "node": ">=6.12"
     },
@@ -12,7 +12,7 @@
     "scripts": {
         "build": "yarn pre_build && tsc -b",
         "build:ci": "yarn build",
-        "pre_build": "run-s compile contracts:gen generate_contract_wrappers",
+        "pre_build": "run-s compile contracts:gen generate_contract_wrappers contracts:copy",
         "test": "yarn run_mocha",
         "rebuild_and_test": "run-s build test",
         "test:coverage": "SOLIDITY_COVERAGE=true run-s build run_mocha coverage:report:text coverage:report:lcov",
@@ -21,21 +21,24 @@
         "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} --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",
+        "clean": "shx rm -rf lib test/generated-artifacts test/generated-wrappers generated-artifacts generated-wrappers",
+        "generate_contract_wrappers": "abi-gen --debug --abis  ${npm_package_config_abis} --output test/generated-wrappers --backend ethers",
+        "lint": "tslint --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./test/generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude ./test/generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
+        "fix": "tslint --fix --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./test/generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude ./test/generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
         "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",
+        "contracts:gen": "contracts-gen generate",
+        "contracts:copy": "contracts-gen copy",
         "lint-contracts": "solhint -c ../.solhint.json contracts/**/**/**/**/*.sol",
-        "compile:truffle": "truffle compile"
+        "compile:truffle": "truffle compile",
+        "docs:md": "ts-doc-gen --sourceDir='$PROJECT_FILES' --output=$MD_FILE_DIR --fileExtension=mdx --tsconfig=./typedoc-tsconfig.json",
+        "docs:json": "typedoc --excludePrivate --excludeExternals --excludeProtected --ignoreCompilerErrors --target ES5 --tsconfig typedoc-tsconfig.json --json $JSON_FILE_PATH $PROJECT_FILES"
     },
     "config": {
-        "abis": "./generated-artifacts/@(ERC1155Proxy|ERC20BridgeProxy|ERC20Proxy|ERC721Proxy|Eth2DaiBridge|IAssetData|IAssetProxy|IAssetProxyDispatcher|IAuthorizable|IERC20Bridge|IEth2Dai|IWallet|MixinAssetProxyDispatcher|MixinAuthorizable|MultiAssetProxy|Ownable|StaticCallProxy|TestERC20Bridge|TestEth2DaiBridge|TestStaticCallTarget).json",
+        "abis": "./test/generated-artifacts/@(ChaiBridge|DydxBridge|ERC1155Proxy|ERC20BridgeProxy|ERC20Proxy|ERC721Proxy|Eth2DaiBridge|IAssetData|IAssetProxy|IAssetProxyDispatcher|IAuthorizable|IChai|IDydx|IDydxBridge|IERC20Bridge|IEth2Dai|IKyberNetworkProxy|IUniswapExchange|IUniswapExchangeFactory|KyberBridge|MixinAssetProxyDispatcher|MixinAuthorizable|MultiAssetProxy|Ownable|StaticCallProxy|TestChaiBridge|TestDydxBridge|TestERC20Bridge|TestEth2DaiBridge|TestKyberBridge|TestStaticCallTarget|TestUniswapBridge|UniswapBridge).json",
         "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually."
     },
     "repository": {
@@ -48,12 +51,15 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/protocol/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^4.3.0-beta.0",
-        "@0x/contracts-gen": "^1.1.0-beta.0",
-        "@0x/contracts-test-utils": "^3.2.0-beta.0",
-        "@0x/dev-utils": "^2.4.0-beta.0",
-        "@0x/sol-compiler": "^3.2.0-beta.0",
-        "@0x/tslint-config": "^3.0.1",
+        "@0x/abi-gen": "^5.1.0",
+        "@0x/contracts-gen": "^2.0.4",
+        "@0x/contracts-test-utils": "^5.1.1",
+        "@0x/contracts-utils": "^4.1.0",
+        "@0x/dev-utils": "^3.1.1",
+        "@0x/sol-compiler": "^4.0.4",
+        "@0x/ts-doc-gen": "^0.0.22",
+        "@0x/tslint-config": "^4.0.0",
+        "@0x/types": "^3.1.1",
         "@types/lodash": "4.14.104",
         "@types/mocha": "^5.2.7",
         "@types/node": "*",
@@ -61,6 +67,7 @@
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
+        "ethereumjs-util": "^5.1.1",
         "make-promises-safe": "^1.1.0",
         "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
@@ -68,21 +75,21 @@
         "solhint": "^1.4.1",
         "truffle": "^5.0.32",
         "tslint": "5.11.0",
+        "typedoc": "^0.15.0",
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.5.0-beta.0",
-        "@0x/contracts-erc1155": "^1.2.0-beta.0",
-        "@0x/contracts-erc20": "^2.3.0-beta.0",
-        "@0x/contracts-erc721": "^2.2.0-beta.0",
-        "@0x/contracts-utils": "^3.3.0-beta.0",
-        "@0x/order-utils": "^8.5.0-beta.0",
-        "@0x/types": "^2.5.0-beta.0",
-        "@0x/typescript-typings": "^4.4.0-beta.0",
-        "@0x/utils": "^4.6.0-beta.0",
-        "@0x/web3-wrapper": "^6.1.0-beta.0",
-        "ethereum-types": "^2.2.0-beta.0",
-        "ethereumjs-util": "^5.1.1",
+        "@0x/base-contract": "^6.1.0",
+        "@0x/contracts-dev-utils": "^1.0.4",
+        "@0x/contracts-erc1155": "^2.0.4",
+        "@0x/contracts-erc20": "^3.0.4",
+        "@0x/contracts-erc721": "^3.0.4",
+        "@0x/contracts-exchange-libs": "^4.1.0",
+        "@0x/order-utils": "^10.1.1",
+        "@0x/typescript-typings": "^5.0.1",
+        "@0x/utils": "^5.2.0",
+        "@0x/web3-wrapper": "^7.0.4",
+        "ethereum-types": "^3.0.0",
         "lodash": "^4.17.11"
     },
     "publishConfig": {

contracts/asset-proxy/src/artifacts.ts

@@ -5,6 +5,8 @@
  */
 import { ContractArtifact } from 'ethereum-types';
 
+import * as ChaiBridge from '../generated-artifacts/ChaiBridge.json';
+import * as DydxBridge from '../generated-artifacts/DydxBridge.json';
 import * as ERC1155Proxy from '../generated-artifacts/ERC1155Proxy.json';
 import * as ERC20BridgeProxy from '../generated-artifacts/ERC20BridgeProxy.json';
 import * as ERC20Proxy from '../generated-artifacts/ERC20Proxy.json';
@@ -14,17 +16,28 @@ import * as IAssetData from '../generated-artifacts/IAssetData.json';
 import * as IAssetProxy from '../generated-artifacts/IAssetProxy.json';
 import * as IAssetProxyDispatcher from '../generated-artifacts/IAssetProxyDispatcher.json';
 import * as IAuthorizable from '../generated-artifacts/IAuthorizable.json';
+import * as IChai from '../generated-artifacts/IChai.json';
+import * as IDydx from '../generated-artifacts/IDydx.json';
+import * as IDydxBridge from '../generated-artifacts/IDydxBridge.json';
 import * as IERC20Bridge from '../generated-artifacts/IERC20Bridge.json';
 import * as IEth2Dai from '../generated-artifacts/IEth2Dai.json';
-import * as IWallet from '../generated-artifacts/IWallet.json';
+import * as IKyberNetworkProxy from '../generated-artifacts/IKyberNetworkProxy.json';
+import * as IUniswapExchange from '../generated-artifacts/IUniswapExchange.json';
+import * as IUniswapExchangeFactory from '../generated-artifacts/IUniswapExchangeFactory.json';
+import * as KyberBridge from '../generated-artifacts/KyberBridge.json';
 import * as MixinAssetProxyDispatcher from '../generated-artifacts/MixinAssetProxyDispatcher.json';
 import * as MixinAuthorizable from '../generated-artifacts/MixinAuthorizable.json';
 import * as MultiAssetProxy from '../generated-artifacts/MultiAssetProxy.json';
 import * as Ownable from '../generated-artifacts/Ownable.json';
 import * as StaticCallProxy from '../generated-artifacts/StaticCallProxy.json';
+import * as TestChaiBridge from '../generated-artifacts/TestChaiBridge.json';
+import * as TestDydxBridge from '../generated-artifacts/TestDydxBridge.json';
 import * as TestERC20Bridge from '../generated-artifacts/TestERC20Bridge.json';
 import * as TestEth2DaiBridge from '../generated-artifacts/TestEth2DaiBridge.json';
+import * as TestKyberBridge from '../generated-artifacts/TestKyberBridge.json';
 import * as TestStaticCallTarget from '../generated-artifacts/TestStaticCallTarget.json';
+import * as TestUniswapBridge from '../generated-artifacts/TestUniswapBridge.json';
+import * as UniswapBridge from '../generated-artifacts/UniswapBridge.json';
 export const artifacts = {
     MixinAssetProxyDispatcher: MixinAssetProxyDispatcher as ContractArtifact,
     MixinAuthorizable: MixinAuthorizable as ContractArtifact,
@@ -35,15 +48,28 @@ export const artifacts = {
     ERC721Proxy: ERC721Proxy as ContractArtifact,
     MultiAssetProxy: MultiAssetProxy as ContractArtifact,
     StaticCallProxy: StaticCallProxy as ContractArtifact,
+    ChaiBridge: ChaiBridge as ContractArtifact,
+    DydxBridge: DydxBridge as ContractArtifact,
     Eth2DaiBridge: Eth2DaiBridge as ContractArtifact,
+    KyberBridge: KyberBridge as ContractArtifact,
+    UniswapBridge: UniswapBridge as ContractArtifact,
     IAssetData: IAssetData as ContractArtifact,
     IAssetProxy: IAssetProxy as ContractArtifact,
     IAssetProxyDispatcher: IAssetProxyDispatcher as ContractArtifact,
     IAuthorizable: IAuthorizable as ContractArtifact,
+    IChai: IChai as ContractArtifact,
+    IDydx: IDydx as ContractArtifact,
+    IDydxBridge: IDydxBridge as ContractArtifact,
     IERC20Bridge: IERC20Bridge as ContractArtifact,
     IEth2Dai: IEth2Dai as ContractArtifact,
-    IWallet: IWallet as ContractArtifact,
+    IKyberNetworkProxy: IKyberNetworkProxy as ContractArtifact,
+    IUniswapExchange: IUniswapExchange as ContractArtifact,
+    IUniswapExchangeFactory: IUniswapExchangeFactory as ContractArtifact,
+    TestChaiBridge: TestChaiBridge as ContractArtifact,
+    TestDydxBridge: TestDydxBridge as ContractArtifact,
     TestERC20Bridge: TestERC20Bridge as ContractArtifact,
     TestEth2DaiBridge: TestEth2DaiBridge as ContractArtifact,
+    TestKyberBridge: TestKyberBridge as ContractArtifact,
     TestStaticCallTarget: TestStaticCallTarget as ContractArtifact,
+    TestUniswapBridge: TestUniswapBridge as ContractArtifact,
 };

contracts/asset-proxy/src/dydx_bridge_encoder.ts

@@ -0,0 +1,40 @@
+import { AbiEncoder, BigNumber } from '@0x/utils';
+
+export enum DydxBridgeActionType {
+    Deposit,
+    Withdraw,
+}
+
+export interface DydxBrigeAction {
+    actionType: DydxBridgeActionType;
+    accountId: BigNumber;
+    marketId: BigNumber;
+    conversionRateNumerator: BigNumber;
+    conversionRateDenominator: BigNumber;
+}
+
+export interface DydxBridgeData {
+    accountNumbers: BigNumber[];
+    actions: DydxBrigeAction[];
+}
+
+export const dydxBridgeDataEncoder = AbiEncoder.create([
+    {
+        name: 'bridgeData',
+        type: 'tuple',
+        components: [
+            { name: 'accountNumbers', type: 'uint256[]' },
+            {
+                name: 'actions',
+                type: 'tuple[]',
+                components: [
+                    { name: 'actionType', type: 'uint8' },
+                    { name: 'accountId', type: 'uint256' },
+                    { name: 'marketId', type: 'uint256' },
+                    { name: 'conversionRateNumerator', type: 'uint256' },
+                    { name: 'conversionRateDenominator', type: 'uint256' },
+                ],
+            },
+        ],
+    },
+]);

contracts/asset-proxy/src/erc1155_proxy_wrapper.ts

@@ -1,3 +1,4 @@
+import { DevUtilsContract } from '@0x/contracts-dev-utils';
 import { artifacts as erc1155Artifacts, ERC1155MintableContract, Erc1155Wrapper } from '@0x/contracts-erc1155';
 import {
     constants,
@@ -7,13 +8,14 @@ import {
     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';
+import { artifacts } from './artifacts';
+
+import { ERC1155ProxyContract, IAssetProxyContract } from './wrappers';
 
 export class ERC1155ProxyWrapper {
     private readonly _tokenOwnerAddresses: string[];
@@ -26,6 +28,7 @@ export class ERC1155ProxyWrapper {
     private readonly _logDecoder: LogDecoder;
     private readonly _dummyTokenWrappers: Erc1155Wrapper[];
     private readonly _assetProxyInterface: IAssetProxyContract;
+    private readonly _devUtils: DevUtilsContract;
     private _proxyContract?: ERC1155ProxyContract;
     private _proxyIdIfExists?: string;
     private _initialTokenIdsByOwner: ERC1155HoldingsByOwner = { fungible: {}, nonFungible: {} };
@@ -37,6 +40,7 @@ export class ERC1155ProxyWrapper {
         this._logDecoder = new LogDecoder(this._web3Wrapper, allArtifacts);
         this._dummyTokenWrappers = [];
         this._assetProxyInterface = new IAssetProxyContract(constants.NULL_ADDRESS, provider);
+        this._devUtils = new DevUtilsContract(constants.NULL_ADDRESS, provider);
         this._tokenOwnerAddresses = tokenOwnerAddresses;
         this._contractOwnerAddress = contractOwnerAddress;
         this._fungibleTokenIds = [];
@@ -56,7 +60,7 @@ export class ERC1155ProxyWrapper {
                 txDefaults,
                 artifacts,
             );
-            const erc1155Wrapper = new Erc1155Wrapper(erc1155Contract, this._provider, this._contractOwnerAddress);
+            const erc1155Wrapper = new Erc1155Wrapper(erc1155Contract, this._contractOwnerAddress);
             this._dummyTokenWrappers.push(erc1155Wrapper);
         }
         return this._dummyTokenWrappers;
@@ -72,7 +76,7 @@ export class ERC1155ProxyWrapper {
             txDefaults,
             artifacts,
         );
-        this._proxyIdIfExists = await this._proxyContract.getProxyId.callAsync();
+        this._proxyIdIfExists = await this._proxyContract.getProxyId().callAsync();
         return this._proxyContract;
     }
     /**
@@ -95,7 +99,7 @@ export class ERC1155ProxyWrapper {
      * @param extraData extra data to append to `transferFrom` transaction. Optional.
      * @return abi encoded tx data.
      */
-    public getTransferFromAbiEncodedTxData(
+    public async getTransferFromAbiEncodedTxDataAsync(
         from: string,
         to: string,
         contractAddress: string,
@@ -105,23 +109,17 @@ export class ERC1155ProxyWrapper {
         receiverCallbackData: string,
         authorizedSender: string,
         assetData_?: string,
-    ): string {
+    ): Promise<string> {
         this._validateProxyContractExistsOrThrow();
         const assetData =
             assetData_ === undefined
-                ? assetDataUtils.encodeERC1155AssetData(
-                      contractAddress,
-                      tokensToTransfer,
-                      valuesToTransfer,
-                      receiverCallbackData,
-                  )
+                ? await this._devUtils
+                      .encodeERC1155AssetData(contractAddress, tokensToTransfer, valuesToTransfer, receiverCallbackData)
+                      .callAsync()
                 : assetData_;
-        const data = this._assetProxyInterface.transferFrom.getABIEncodedTransactionData(
-            assetData,
-            from,
-            to,
-            valueMultiplier,
-        );
+        const data = this._assetProxyInterface
+            .transferFrom(assetData, from, to, valueMultiplier)
+            .getABIEncodedTransactionData();
         return data;
     }
     /**
@@ -169,19 +167,13 @@ export class ERC1155ProxyWrapper {
         this._validateProxyContractExistsOrThrow();
         const assetData =
             assetData_ === undefined
-                ? assetDataUtils.encodeERC1155AssetData(
-                      contractAddress,
-                      tokensToTransfer,
-                      valuesToTransfer,
-                      receiverCallbackData,
-                  )
+                ? await this._devUtils
+                      .encodeERC1155AssetData(contractAddress, tokensToTransfer, valuesToTransfer, receiverCallbackData)
+                      .callAsync()
                 : assetData_;
-        const data = this._assetProxyInterface.transferFrom.getABIEncodedTransactionData(
-            assetData,
-            from,
-            to,
-            valueMultiplier,
-        );
+        const data = this._assetProxyInterface
+            .transferFrom(assetData, from, to, valueMultiplier)
+            .getABIEncodedTransactionData();
         const txHash = await this._web3Wrapper.sendTransactionAsync({
             to: (this._proxyContract as ERC1155ProxyContract).address,
             data,
@@ -362,7 +354,7 @@ export class ERC1155ProxyWrapper {
         this._validateProxyContractExistsOrThrow();
         const tokenContract = this._getContractFromAddress(contractAddress);
         const operator = (this._proxyContract as ERC1155ProxyContract).address;
-        const didApproveAll = await tokenContract.isApprovedForAll.callAsync(userAddress, operator);
+        const didApproveAll = await tokenContract.isApprovedForAll(userAddress, operator).callAsync();
         return didApproveAll;
     }
     public getFungibleTokenIds(): BigNumber[] {

contracts/asset-proxy/src/erc20_wrapper.ts

@@ -1,17 +1,20 @@
+import { DevUtilsContract } from '@0x/contracts-dev-utils';
 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 { ZeroExProvider } from 'ethereum-types';
 import * as _ from 'lodash';
 
-import { artifacts, ERC20ProxyContract } from '../../src';
+import { artifacts } from './artifacts';
+
+import { ERC20ProxyContract } from './wrappers';
 
 export class ERC20Wrapper {
     private readonly _tokenOwnerAddresses: string[];
     private readonly _contractOwnerAddress: string;
     private readonly _provider: ZeroExProvider;
     private readonly _dummyTokenContracts: DummyERC20TokenContract[];
+    private readonly _devUtils: DevUtilsContract;
     private _proxyContract?: ERC20ProxyContract;
     private _proxyIdIfExists?: string;
     /**
@@ -26,6 +29,7 @@ export class ERC20Wrapper {
         this._provider = provider;
         this._tokenOwnerAddresses = tokenOwnerAddresses;
         this._contractOwnerAddress = contractOwnerAddress;
+        this._devUtils = new DevUtilsContract(constants.NULL_ADDRESS, provider);
     }
     public async deployDummyTokensAsync(
         numberToDeploy: number,
@@ -54,7 +58,7 @@ export class ERC20Wrapper {
             txDefaults,
             artifacts,
         );
-        this._proxyIdIfExists = await this._proxyContract.getProxyId.callAsync();
+        this._proxyIdIfExists = await this._proxyContract.getProxyId().callAsync();
         return this._proxyContract;
     }
     public getProxyId(): string {
@@ -66,50 +70,39 @@ export class ERC20Wrapper {
         this._validateProxyContractExistsOrThrow();
         for (const dummyTokenContract of this._dummyTokenContracts) {
             for (const tokenOwnerAddress of this._tokenOwnerAddresses) {
-                await dummyTokenContract.setBalance.awaitTransactionSuccessAsync(
-                    tokenOwnerAddress,
-                    constants.INITIAL_ERC20_BALANCE,
-                    { from: this._contractOwnerAddress },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
-                await dummyTokenContract.approve.awaitTransactionSuccessAsync(
-                    (this._proxyContract as ERC20ProxyContract).address,
-                    constants.INITIAL_ERC20_ALLOWANCE,
-                    { from: tokenOwnerAddress },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                await dummyTokenContract
+                    .setBalance(tokenOwnerAddress, constants.INITIAL_ERC20_BALANCE)
+                    .awaitTransactionSuccessAsync({ from: this._contractOwnerAddress });
+                await dummyTokenContract
+                    .approve((this._proxyContract as ERC20ProxyContract).address, constants.INITIAL_ERC20_ALLOWANCE)
+                    .awaitTransactionSuccessAsync({ from: tokenOwnerAddress });
             }
         }
     }
     public async getBalanceAsync(userAddress: string, assetData: string): Promise<BigNumber> {
-        const tokenContract = this._getTokenContractFromAssetData(assetData);
-        const balance = new BigNumber(await tokenContract.balanceOf.callAsync(userAddress));
+        const tokenContract = await this._getTokenContractFromAssetDataAsync(assetData);
+        const balance = new BigNumber(await tokenContract.balanceOf(userAddress).callAsync());
         return balance;
     }
     public async setBalanceAsync(userAddress: string, assetData: string, amount: BigNumber): Promise<void> {
-        const tokenContract = this._getTokenContractFromAssetData(assetData);
-        await tokenContract.setBalance.awaitTransactionSuccessAsync(
-            userAddress,
-            amount,
-            { from: this._contractOwnerAddress },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        const tokenContract = await this._getTokenContractFromAssetDataAsync(assetData);
+        await tokenContract
+            .setBalance(userAddress, amount)
+            .awaitTransactionSuccessAsync(
+                { from: this._contractOwnerAddress },
+                { pollingIntervalMs: constants.AWAIT_TRANSACTION_MINED_MS },
+            );
     }
     public async getProxyAllowanceAsync(userAddress: string, assetData: string): Promise<BigNumber> {
-        const tokenContract = this._getTokenContractFromAssetData(assetData);
+        const tokenContract = await this._getTokenContractFromAssetDataAsync(assetData);
         const proxyAddress = (this._proxyContract as ERC20ProxyContract).address;
-        const allowance = new BigNumber(await tokenContract.allowance.callAsync(userAddress, proxyAddress));
+        const allowance = new BigNumber(await tokenContract.allowance(userAddress, proxyAddress).callAsync());
         return allowance;
     }
     public async setAllowanceAsync(userAddress: string, assetData: string, amount: BigNumber): Promise<void> {
-        const tokenContract = this._getTokenContractFromAssetData(assetData);
+        const tokenContract = await this._getTokenContractFromAssetDataAsync(assetData);
         const proxyAddress = (this._proxyContract as ERC20ProxyContract).address;
-        await tokenContract.approve.awaitTransactionSuccessAsync(
-            proxyAddress,
-            amount,
-            { from: userAddress },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.approve(proxyAddress, amount).awaitTransactionSuccessAsync({ from: userAddress });
     }
     public async getBalancesAsync(): Promise<ERC20BalancesByOwner> {
         this._validateDummyTokenContractsExistOrThrow();
@@ -118,7 +111,7 @@ export class ERC20Wrapper {
         const balanceInfo: Array<{ tokenOwnerAddress: string; tokenAddress: string }> = [];
         for (const dummyTokenContract of this._dummyTokenContracts) {
             for (const tokenOwnerAddress of this._tokenOwnerAddresses) {
-                balances.push(await dummyTokenContract.balanceOf.callAsync(tokenOwnerAddress));
+                balances.push(await dummyTokenContract.balanceOf(tokenOwnerAddress).callAsync());
                 balanceInfo.push({
                     tokenOwnerAddress,
                     tokenAddress: dummyTokenContract.address,
@@ -151,9 +144,8 @@ export class ERC20Wrapper {
         const tokenAddresses = _.map(this._dummyTokenContracts, dummyTokenContract => dummyTokenContract.address);
         return tokenAddresses;
     }
-    private _getTokenContractFromAssetData(assetData: string): DummyERC20TokenContract {
-        const erc20ProxyData = assetDataUtils.decodeERC20AssetData(assetData);
-        const tokenAddress = erc20ProxyData.tokenAddress;
+    private async _getTokenContractFromAssetDataAsync(assetData: string): Promise<DummyERC20TokenContract> {
+        const [proxyId, tokenAddress] = await this._devUtils.decodeERC20AssetData(assetData).callAsync(); // tslint:disable-line:no-unused-variable
         const tokenContractIfExists = _.find(this._dummyTokenContracts, c => c.address === tokenAddress);
         if (tokenContractIfExists === undefined) {
             throw new Error(`Token: ${tokenAddress} was not deployed through ERC20Wrapper`);

contracts/asset-proxy/src/erc721_wrapper.ts

@@ -5,7 +5,9 @@ import { BigNumber } from '@0x/utils';
 import { ZeroExProvider } from 'ethereum-types';
 import * as _ from 'lodash';
 
-import { artifacts, ERC721ProxyContract } from '../../src';
+import { artifacts } from './artifacts';
+
+import { ERC721ProxyContract } from './wrappers';
 
 export class ERC721Wrapper {
     private readonly _tokenOwnerAddresses: string[];
@@ -44,7 +46,7 @@ export class ERC721Wrapper {
             txDefaults,
             artifacts,
         );
-        this._proxyIdIfExists = await this._proxyContract.getProxyId.callAsync();
+        this._proxyIdIfExists = await this._proxyContract.getProxyId().callAsync();
         return this._proxyContract;
     }
     public getProxyId(): string {
@@ -78,7 +80,7 @@ export class ERC721Wrapper {
     }
     public async doesTokenExistAsync(tokenAddress: string, tokenId: BigNumber): Promise<boolean> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        const owner = await tokenContract.ownerOf.callAsync(tokenId);
+        const owner = await tokenContract.ownerOf(tokenId).callAsync();
         const doesExist = owner !== constants.NULL_ADDRESS;
         return doesExist;
     }
@@ -93,22 +95,14 @@ export class ERC721Wrapper {
     ): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
         const proxyAddress = (this._proxyContract as ERC721ProxyContract).address;
-        await tokenContract.setApprovalForAll.awaitTransactionSuccessAsync(
-            proxyAddress,
-            isApproved,
-            { from: ownerAddress },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.setApprovalForAll(proxyAddress, isApproved).awaitTransactionSuccessAsync({
+            from: ownerAddress,
+        });
     }
     public async approveAsync(to: string, tokenAddress: string, tokenId: BigNumber): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
         const tokenOwner = await this.ownerOfAsync(tokenAddress, tokenId);
-        await tokenContract.approve.awaitTransactionSuccessAsync(
-            to,
-            tokenId,
-            { from: tokenOwner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.approve(to, tokenId).awaitTransactionSuccessAsync({ from: tokenOwner });
     }
     public async transferFromAsync(
         tokenAddress: string,
@@ -117,40 +111,28 @@ export class ERC721Wrapper {
         userAddress: string,
     ): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await tokenContract.transferFrom.awaitTransactionSuccessAsync(
-            currentOwner,
-            userAddress,
-            tokenId,
-            { from: currentOwner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.transferFrom(currentOwner, userAddress, tokenId).awaitTransactionSuccessAsync({
+            from: currentOwner,
+        });
     }
     public async mintAsync(tokenAddress: string, tokenId: BigNumber, userAddress: string): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await tokenContract.mint.awaitTransactionSuccessAsync(
-            userAddress,
-            tokenId,
-            { from: this._contractOwnerAddress },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.mint(userAddress, tokenId).awaitTransactionSuccessAsync({
+            from: this._contractOwnerAddress,
+        });
     }
     public async burnAsync(tokenAddress: string, tokenId: BigNumber, owner: string): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await tokenContract.burn.awaitTransactionSuccessAsync(
-            owner,
-            tokenId,
-            { from: this._contractOwnerAddress },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.burn(owner, tokenId).awaitTransactionSuccessAsync({ from: this._contractOwnerAddress });
     }
     public async ownerOfAsync(tokenAddress: string, tokenId: BigNumber): Promise<string> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        const owner = await tokenContract.ownerOf.callAsync(tokenId);
+        const owner = await tokenContract.ownerOf(tokenId).callAsync();
         return owner;
     }
     public async isOwnerAsync(userAddress: string, tokenAddress: string, tokenId: BigNumber): Promise<boolean> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        const tokenOwner = await tokenContract.ownerOf.callAsync(tokenId);
+        const tokenOwner = await tokenContract.ownerOf(tokenId).callAsync();
         const isOwner = tokenOwner === userAddress;
         return isOwner;
     }
@@ -158,13 +140,13 @@ export class ERC721Wrapper {
         this._validateProxyContractExistsOrThrow();
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
         const operator = (this._proxyContract as ERC721ProxyContract).address;
-        const didApproveAll = await tokenContract.isApprovedForAll.callAsync(userAddress, operator);
+        const didApproveAll = await tokenContract.isApprovedForAll(userAddress, operator).callAsync();
         return didApproveAll;
     }
     public async isProxyApprovedAsync(tokenAddress: string, tokenId: BigNumber): Promise<boolean> {
         this._validateProxyContractExistsOrThrow();
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        const approvedAddress = await tokenContract.getApproved.callAsync(tokenId);
+        const approvedAddress = await tokenContract.getApproved(tokenId).callAsync();
         const proxyAddress = (this._proxyContract as ERC721ProxyContract).address;
         const isProxyAnApprovedOperator = approvedAddress === proxyAddress;
         return isProxyAnApprovedOperator;
@@ -181,7 +163,7 @@ export class ERC721Wrapper {
                     dummyTokenContract.address
                 ];
                 for (const tokenId of initialTokenOwnerIds) {
-                    tokenOwnerAddresses.push(await dummyTokenContract.ownerOf.callAsync(tokenId));
+                    tokenOwnerAddresses.push(await dummyTokenContract.ownerOf(tokenId).callAsync());
                     tokenInfo.push({
                         tokenId,
                         tokenAddress: dummyTokenContract.address,

contracts/asset-proxy/src/index.ts

@@ -1,3 +1,70 @@
-export * from './artifacts';
-export * from './wrappers';
-export * from '../test/utils';
+export { artifacts } from './artifacts';
+export {
+    ERC1155ProxyContract,
+    ERC20BridgeProxyContract,
+    ERC20ProxyContract,
+    ERC721ProxyContract,
+    Eth2DaiBridgeContract,
+    DydxBridgeContract,
+    TestDydxBridgeContract,
+    IAssetDataContract,
+    IAssetProxyContract,
+    MultiAssetProxyContract,
+    StaticCallProxyContract,
+    TestStaticCallTargetContract,
+    UniswapBridgeContract,
+    KyberBridgeContract,
+    ChaiBridgeContract,
+    IChaiContract,
+} from './wrappers';
+
+export { ERC20Wrapper } from './erc20_wrapper';
+export { ERC721Wrapper } from './erc721_wrapper';
+export { ERC1155ProxyWrapper } from './erc1155_proxy_wrapper';
+export { ERC1155MintableContract, Erc1155Wrapper } from '@0x/contracts-erc1155';
+export { DummyERC20TokenContract } from '@0x/contracts-erc20';
+export { DummyERC721TokenContract } from '@0x/contracts-erc721';
+export {
+    ERC1155HoldingsByOwner,
+    ERC20BalancesByOwner,
+    ERC721TokenIdsByOwner,
+    ERC1155FungibleHoldingsByOwner,
+    ERC1155NonFungibleHoldingsByOwner,
+} from '@0x/contracts-test-utils';
+export {
+    TransactionReceiptWithDecodedLogs,
+    Provider,
+    ZeroExProvider,
+    JSONRPCRequestPayload,
+    JSONRPCErrorCallback,
+    TransactionReceiptStatus,
+    JSONRPCResponsePayload,
+    JSONRPCResponseError,
+    ContractArtifact,
+    ContractChains,
+    CompilerOpts,
+    StandardContractOutput,
+    CompilerSettings,
+    ContractChainData,
+    ContractAbi,
+    DevdocOutput,
+    EvmOutput,
+    CompilerSettingsMetadata,
+    OptimizerSettings,
+    OutputField,
+    ParamDescription,
+    EvmBytecodeOutput,
+    AbiDefinition,
+    FunctionAbi,
+    EventAbi,
+    RevertErrorAbi,
+    EventParameter,
+    DataItem,
+    MethodAbi,
+    ConstructorAbi,
+    FallbackAbi,
+    ConstructorStateMutability,
+    TupleDataItem,
+    StateMutability,
+} from 'ethereum-types';
+export * from './dydx_bridge_encoder';

contracts/asset-proxy/src/wrappers.ts

@@ -3,6 +3,8 @@
  * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
  * -----------------------------------------------------------------------------
  */
+export * from '../generated-wrappers/chai_bridge';
+export * from '../generated-wrappers/dydx_bridge';
 export * from '../generated-wrappers/erc1155_proxy';
 export * from '../generated-wrappers/erc20_bridge_proxy';
 export * from '../generated-wrappers/erc20_proxy';
@@ -12,14 +14,25 @@ export * from '../generated-wrappers/i_asset_data';
 export * from '../generated-wrappers/i_asset_proxy';
 export * from '../generated-wrappers/i_asset_proxy_dispatcher';
 export * from '../generated-wrappers/i_authorizable';
+export * from '../generated-wrappers/i_chai';
+export * from '../generated-wrappers/i_dydx';
+export * from '../generated-wrappers/i_dydx_bridge';
 export * from '../generated-wrappers/i_erc20_bridge';
 export * from '../generated-wrappers/i_eth2_dai';
-export * from '../generated-wrappers/i_wallet';
+export * from '../generated-wrappers/i_kyber_network_proxy';
+export * from '../generated-wrappers/i_uniswap_exchange';
+export * from '../generated-wrappers/i_uniswap_exchange_factory';
+export * from '../generated-wrappers/kyber_bridge';
 export * from '../generated-wrappers/mixin_asset_proxy_dispatcher';
 export * from '../generated-wrappers/mixin_authorizable';
 export * from '../generated-wrappers/multi_asset_proxy';
 export * from '../generated-wrappers/ownable';
 export * from '../generated-wrappers/static_call_proxy';
+export * from '../generated-wrappers/test_chai_bridge';
+export * from '../generated-wrappers/test_dydx_bridge';
 export * from '../generated-wrappers/test_erc20_bridge';
 export * from '../generated-wrappers/test_eth2_dai_bridge';
+export * from '../generated-wrappers/test_kyber_bridge';
 export * from '../generated-wrappers/test_static_call_target';
+export * from '../generated-wrappers/test_uniswap_bridge';
+export * from '../generated-wrappers/uniswap_bridge';

contracts/asset-proxy/test/artifacts.ts

@@ -0,0 +1,75 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+import { ContractArtifact } from 'ethereum-types';
+
+import * as ChaiBridge from '../test/generated-artifacts/ChaiBridge.json';
+import * as DydxBridge from '../test/generated-artifacts/DydxBridge.json';
+import * as ERC1155Proxy from '../test/generated-artifacts/ERC1155Proxy.json';
+import * as ERC20BridgeProxy from '../test/generated-artifacts/ERC20BridgeProxy.json';
+import * as ERC20Proxy from '../test/generated-artifacts/ERC20Proxy.json';
+import * as ERC721Proxy from '../test/generated-artifacts/ERC721Proxy.json';
+import * as Eth2DaiBridge from '../test/generated-artifacts/Eth2DaiBridge.json';
+import * as IAssetData from '../test/generated-artifacts/IAssetData.json';
+import * as IAssetProxy from '../test/generated-artifacts/IAssetProxy.json';
+import * as IAssetProxyDispatcher from '../test/generated-artifacts/IAssetProxyDispatcher.json';
+import * as IAuthorizable from '../test/generated-artifacts/IAuthorizable.json';
+import * as IChai from '../test/generated-artifacts/IChai.json';
+import * as IDydx from '../test/generated-artifacts/IDydx.json';
+import * as IDydxBridge from '../test/generated-artifacts/IDydxBridge.json';
+import * as IERC20Bridge from '../test/generated-artifacts/IERC20Bridge.json';
+import * as IEth2Dai from '../test/generated-artifacts/IEth2Dai.json';
+import * as IKyberNetworkProxy from '../test/generated-artifacts/IKyberNetworkProxy.json';
+import * as IUniswapExchange from '../test/generated-artifacts/IUniswapExchange.json';
+import * as IUniswapExchangeFactory from '../test/generated-artifacts/IUniswapExchangeFactory.json';
+import * as KyberBridge from '../test/generated-artifacts/KyberBridge.json';
+import * as MixinAssetProxyDispatcher from '../test/generated-artifacts/MixinAssetProxyDispatcher.json';
+import * as MixinAuthorizable from '../test/generated-artifacts/MixinAuthorizable.json';
+import * as MultiAssetProxy from '../test/generated-artifacts/MultiAssetProxy.json';
+import * as Ownable from '../test/generated-artifacts/Ownable.json';
+import * as StaticCallProxy from '../test/generated-artifacts/StaticCallProxy.json';
+import * as TestChaiBridge from '../test/generated-artifacts/TestChaiBridge.json';
+import * as TestDydxBridge from '../test/generated-artifacts/TestDydxBridge.json';
+import * as TestERC20Bridge from '../test/generated-artifacts/TestERC20Bridge.json';
+import * as TestEth2DaiBridge from '../test/generated-artifacts/TestEth2DaiBridge.json';
+import * as TestKyberBridge from '../test/generated-artifacts/TestKyberBridge.json';
+import * as TestStaticCallTarget from '../test/generated-artifacts/TestStaticCallTarget.json';
+import * as TestUniswapBridge from '../test/generated-artifacts/TestUniswapBridge.json';
+import * as UniswapBridge from '../test/generated-artifacts/UniswapBridge.json';
+export const artifacts = {
+    MixinAssetProxyDispatcher: MixinAssetProxyDispatcher as ContractArtifact,
+    MixinAuthorizable: MixinAuthorizable as ContractArtifact,
+    Ownable: Ownable as ContractArtifact,
+    ERC1155Proxy: ERC1155Proxy as ContractArtifact,
+    ERC20BridgeProxy: ERC20BridgeProxy as ContractArtifact,
+    ERC20Proxy: ERC20Proxy as ContractArtifact,
+    ERC721Proxy: ERC721Proxy as ContractArtifact,
+    MultiAssetProxy: MultiAssetProxy as ContractArtifact,
+    StaticCallProxy: StaticCallProxy as ContractArtifact,
+    ChaiBridge: ChaiBridge as ContractArtifact,
+    DydxBridge: DydxBridge as ContractArtifact,
+    Eth2DaiBridge: Eth2DaiBridge as ContractArtifact,
+    KyberBridge: KyberBridge as ContractArtifact,
+    UniswapBridge: UniswapBridge as ContractArtifact,
+    IAssetData: IAssetData as ContractArtifact,
+    IAssetProxy: IAssetProxy as ContractArtifact,
+    IAssetProxyDispatcher: IAssetProxyDispatcher as ContractArtifact,
+    IAuthorizable: IAuthorizable as ContractArtifact,
+    IChai: IChai as ContractArtifact,
+    IDydx: IDydx as ContractArtifact,
+    IDydxBridge: IDydxBridge as ContractArtifact,
+    IERC20Bridge: IERC20Bridge as ContractArtifact,
+    IEth2Dai: IEth2Dai as ContractArtifact,
+    IKyberNetworkProxy: IKyberNetworkProxy as ContractArtifact,
+    IUniswapExchange: IUniswapExchange as ContractArtifact,
+    IUniswapExchangeFactory: IUniswapExchangeFactory as ContractArtifact,
+    TestChaiBridge: TestChaiBridge as ContractArtifact,
+    TestDydxBridge: TestDydxBridge as ContractArtifact,
+    TestERC20Bridge: TestERC20Bridge as ContractArtifact,
+    TestEth2DaiBridge: TestEth2DaiBridge as ContractArtifact,
+    TestKyberBridge: TestKyberBridge as ContractArtifact,
+    TestStaticCallTarget: TestStaticCallTarget as ContractArtifact,
+    TestUniswapBridge: TestUniswapBridge as ContractArtifact,
+};

contracts/asset-proxy/test/authorizable.ts

@@ -1,18 +1,13 @@
-import {
-    chaiSetup,
-    constants,
-    expectTransactionFailedAsync,
-    provider,
-    txDefaults,
-    web3Wrapper,
-} from '@0x/contracts-test-utils';
+import { chaiSetup, expectTransactionFailedAsync, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
 import { BlockchainLifecycle } from '@0x/dev-utils';
 import { RevertReason } from '@0x/types';
 import { BigNumber } from '@0x/utils';
 import * as chai from 'chai';
 import * as _ from 'lodash';
 
-import { artifacts, MixinAuthorizableContract } from '../src';
+import { artifacts } from './artifacts';
+
+import { MixinAuthorizableContract } from './wrappers';
 
 chaiSetup.configure();
 const expect = chai.expect;
@@ -54,29 +49,21 @@ describe('Authorizable', () => {
     describe('addAuthorizedAddress', () => {
         it('should revert if not called by owner', async () => {
             await expectTransactionFailedAsync(
-                authorizable.addAuthorizedAddress.sendTransactionAsync(notOwner, { from: notOwner }),
+                authorizable.addAuthorizedAddress(notOwner).sendTransactionAsync({ from: notOwner }),
                 RevertReason.OnlyContractOwner,
             );
         });
 
         it('should allow owner to add an authorized address', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
-            const isAuthorized = await authorizable.authorized.callAsync(address);
+            await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner });
+            const isAuthorized = await authorizable.authorized(address).callAsync();
             expect(isAuthorized).to.be.true();
         });
 
         it('should revert if owner attempts to authorize a duplicate address', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner });
             return expectTransactionFailedAsync(
-                authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+                authorizable.addAuthorizedAddress(address).sendTransactionAsync({ from: owner }),
                 RevertReason.TargetAlreadyAuthorized,
             );
         });
@@ -84,35 +71,23 @@ describe('Authorizable', () => {
 
     describe('removeAuthorizedAddress', () => {
         it('should revert if not called by owner', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner });
             await expectTransactionFailedAsync(
-                authorizable.removeAuthorizedAddress.sendTransactionAsync(address, { from: notOwner }),
+                authorizable.removeAuthorizedAddress(address).sendTransactionAsync({ from: notOwner }),
                 RevertReason.OnlyContractOwner,
             );
         });
 
         it('should allow owner to remove an authorized address', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
-            await authorizable.removeAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
-            const isAuthorized = await authorizable.authorized.callAsync(address);
+            await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner });
+            await authorizable.removeAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner });
+            const isAuthorized = await authorizable.authorized(address).callAsync();
             expect(isAuthorized).to.be.false();
         });
 
         it('should revert if owner attempts to remove an address that is not authorized', async () => {
             return expectTransactionFailedAsync(
-                authorizable.removeAuthorizedAddress.sendTransactionAsync(address, {
+                authorizable.removeAuthorizedAddress(address).sendTransactionAsync({
                     from: owner,
                 }),
                 RevertReason.TargetNotAuthorized,
@@ -122,14 +97,10 @@ describe('Authorizable', () => {
 
     describe('removeAuthorizedAddressAtIndex', () => {
         it('should revert if not called by owner', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner });
             const index = new BigNumber(0);
             await expectTransactionFailedAsync(
-                authorizable.removeAuthorizedAddressAtIndex.sendTransactionAsync(address, index, {
+                authorizable.removeAuthorizedAddressAtIndex(address, index).sendTransactionAsync({
                     from: notOwner,
                 }),
                 RevertReason.OnlyContractOwner,
@@ -137,14 +108,10 @@ describe('Authorizable', () => {
         });
 
         it('should revert if index is >= authorities.length', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner });
             const index = new BigNumber(1);
             return expectTransactionFailedAsync(
-                authorizable.removeAuthorizedAddressAtIndex.sendTransactionAsync(address, index, {
+                authorizable.removeAuthorizedAddressAtIndex(address, index).sendTransactionAsync({
                     from: owner,
                 }),
                 RevertReason.IndexOutOfBounds,
@@ -154,7 +121,7 @@ describe('Authorizable', () => {
         it('should revert if owner attempts to remove an address that is not authorized', async () => {
             const index = new BigNumber(0);
             return expectTransactionFailedAsync(
-                authorizable.removeAuthorizedAddressAtIndex.sendTransactionAsync(address, index, {
+                authorizable.removeAuthorizedAddressAtIndex(address, index).sendTransactionAsync({
                     from: owner,
                 }),
                 RevertReason.TargetNotAuthorized,
@@ -164,19 +131,11 @@ describe('Authorizable', () => {
         it('should revert if address at index does not match target', async () => {
             const address1 = address;
             const address2 = notOwner;
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address1,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address2,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress(address1).awaitTransactionSuccessAsync({ from: owner });
+            await authorizable.addAuthorizedAddress(address2).awaitTransactionSuccessAsync({ from: owner });
             const address1Index = new BigNumber(0);
             return expectTransactionFailedAsync(
-                authorizable.removeAuthorizedAddressAtIndex.sendTransactionAsync(address2, address1Index, {
+                authorizable.removeAuthorizedAddressAtIndex(address2, address1Index).sendTransactionAsync({
                     from: owner,
                 }),
                 RevertReason.AuthorizedAddressMismatch,
@@ -184,41 +143,26 @@ describe('Authorizable', () => {
         });
 
         it('should allow owner to remove an authorized address', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner });
             const index = new BigNumber(0);
-            await authorizable.removeAuthorizedAddressAtIndex.awaitTransactionSuccessAsync(
-                address,
-                index,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
-            const isAuthorized = await authorizable.authorized.callAsync(address);
+            await authorizable.removeAuthorizedAddressAtIndex(address, index).awaitTransactionSuccessAsync({
+                from: owner,
+            });
+            const isAuthorized = await authorizable.authorized(address).callAsync();
             expect(isAuthorized).to.be.false();
         });
     });
 
     describe('getAuthorizedAddresses', () => {
         it('should return all authorized addresses', async () => {
-            const initial = await authorizable.getAuthorizedAddresses.callAsync();
+            const initial = await authorizable.getAuthorizedAddresses().callAsync();
             expect(initial).to.have.length(0);
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
-            const afterAdd = await authorizable.getAuthorizedAddresses.callAsync();
+            await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner });
+            const afterAdd = await authorizable.getAuthorizedAddresses().callAsync();
             expect(afterAdd).to.have.length(1);
             expect(afterAdd).to.include(address);
-            await authorizable.removeAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
-            const afterRemove = await authorizable.getAuthorizedAddresses.callAsync();
+            await authorizable.removeAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner });
+            const afterRemove = await authorizable.getAuthorizedAddresses().callAsync();
             expect(afterRemove).to.have.length(0);
         });
     });

contracts/asset-proxy/test/chai_bridge.ts

@@ -0,0 +1,60 @@
+import { ERC20TokenContract } from '@0x/contracts-erc20';
+import { blockchainTests, constants, expect, randomAddress } from '@0x/contracts-test-utils';
+import { AssetProxyId, RevertReason } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+
+import { artifacts } from './artifacts';
+import { TestChaiBridgeContract } from './wrappers';
+
+blockchainTests.resets('ChaiBridge unit tests', env => {
+    let chaiBridgeContract: TestChaiBridgeContract;
+    let testDaiContract: ERC20TokenContract;
+    let fromAddress: string;
+    let toAddress: string;
+
+    const alwaysRevertAddress = '0x0000000000000000000000000000000000000001';
+    const amount = new BigNumber(1);
+
+    before(async () => {
+        [fromAddress, toAddress] = await env.getAccountAddressesAsync();
+        chaiBridgeContract = await TestChaiBridgeContract.deployFrom0xArtifactAsync(
+            artifacts.TestChaiBridge,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+        );
+        const testChaiDaiAddress = await chaiBridgeContract.testChaiDai().callAsync();
+        testDaiContract = new ERC20TokenContract(testChaiDaiAddress, env.provider, env.txDefaults);
+    });
+
+    describe('bridgeTransferFrom()', () => {
+        it('fails if not called by ERC20BridgeProxy', async () => {
+            return expect(
+                chaiBridgeContract
+                    .bridgeTransferFrom(randomAddress(), fromAddress, toAddress, amount, constants.NULL_BYTES)
+                    .awaitTransactionSuccessAsync({ from: alwaysRevertAddress }),
+            ).to.revertWith(RevertReason.ChaiBridgeOnlyCallableByErc20BridgeProxy);
+        });
+        it('returns magic bytes upon success', async () => {
+            const magicBytes = await chaiBridgeContract
+                .bridgeTransferFrom(randomAddress(), fromAddress, toAddress, amount, constants.NULL_BYTES)
+                .callAsync();
+            expect(magicBytes).to.eq(AssetProxyId.ERC20Bridge);
+        });
+        it('should increase the Dai balance of `toAddress` by `amount` if successful', async () => {
+            const initialBalance = await testDaiContract.balanceOf(toAddress).callAsync();
+            await chaiBridgeContract
+                .bridgeTransferFrom(randomAddress(), fromAddress, toAddress, amount, constants.NULL_BYTES)
+                .awaitTransactionSuccessAsync();
+            const endBalance = await testDaiContract.balanceOf(toAddress).callAsync();
+            expect(endBalance).to.bignumber.eq(initialBalance.plus(amount));
+        });
+        it('fails if the `chai.draw` call fails', async () => {
+            return expect(
+                chaiBridgeContract
+                    .bridgeTransferFrom(randomAddress(), alwaysRevertAddress, toAddress, amount, constants.NULL_BYTES)
+                    .awaitTransactionSuccessAsync(),
+            ).to.revertWith(RevertReason.ChaiBridgeDrawDaiFailed);
+        });
+    });
+});

contracts/asset-proxy/test/dydx_bridge.ts

@@ -0,0 +1,399 @@
+import { LibMathRevertErrors } from '@0x/contracts-exchange-libs';
+import { blockchainTests, constants, expect, verifyEventsFromLogs } from '@0x/contracts-test-utils';
+import { AssetProxyId, RevertReason } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+import * as _ from 'lodash';
+
+import { DydxBridgeActionType, DydxBridgeData, dydxBridgeDataEncoder } from '../src/dydx_bridge_encoder';
+import { ERC20BridgeProxyContract, IAssetDataContract } from '../src/wrappers';
+
+import { artifacts } from './artifacts';
+import { TestDydxBridgeContract, TestDydxBridgeEvents } from './wrappers';
+
+blockchainTests.resets('DydxBridge unit tests', env => {
+    const defaultAccountNumber = new BigNumber(1);
+    const marketId = new BigNumber(2);
+    const defaultAmount = new BigNumber(4);
+    const notAuthorized = '0x0000000000000000000000000000000000000001';
+    const defaultDepositAction = {
+        actionType: DydxBridgeActionType.Deposit,
+        accountId: constants.ZERO_AMOUNT,
+        marketId,
+        conversionRateNumerator: constants.ZERO_AMOUNT,
+        conversionRateDenominator: constants.ZERO_AMOUNT,
+    };
+    const defaultWithdrawAction = {
+        actionType: DydxBridgeActionType.Withdraw,
+        accountId: constants.ZERO_AMOUNT,
+        marketId,
+        conversionRateNumerator: constants.ZERO_AMOUNT,
+        conversionRateDenominator: constants.ZERO_AMOUNT,
+    };
+    let testContract: TestDydxBridgeContract;
+    let testProxyContract: ERC20BridgeProxyContract;
+    let assetDataEncoder: IAssetDataContract;
+    let owner: string;
+    let authorized: string;
+    let accountOwner: string;
+    let receiver: string;
+
+    before(async () => {
+        // Get accounts
+        const accounts = await env.web3Wrapper.getAvailableAddressesAsync();
+        [owner, authorized, accountOwner, receiver] = accounts;
+
+        // Deploy dydx bridge
+        testContract = await TestDydxBridgeContract.deployFrom0xArtifactAsync(
+            artifacts.TestDydxBridge,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+            [accountOwner, receiver],
+        );
+
+        // Deploy test erc20 bridge proxy
+        testProxyContract = await ERC20BridgeProxyContract.deployFrom0xArtifactAsync(
+            artifacts.ERC20BridgeProxy,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+        );
+        await testProxyContract.addAuthorizedAddress(authorized).awaitTransactionSuccessAsync({ from: owner });
+
+        // Setup asset data encoder
+        assetDataEncoder = new IAssetDataContract(constants.NULL_ADDRESS, env.provider);
+    });
+
+    describe('bridgeTransferFrom()', () => {
+        const callBridgeTransferFrom = async (
+            from: string,
+            to: string,
+            amount: BigNumber,
+            bridgeData: DydxBridgeData,
+            sender: string,
+        ): Promise<string> => {
+            const returnValue = await testContract
+                .bridgeTransferFrom(
+                    constants.NULL_ADDRESS,
+                    from,
+                    to,
+                    amount,
+                    dydxBridgeDataEncoder.encode({ bridgeData }),
+                )
+                .callAsync({ from: sender });
+            return returnValue;
+        };
+        const executeBridgeTransferFromAndVerifyEvents = async (
+            from: string,
+            to: string,
+            amount: BigNumber,
+            bridgeData: DydxBridgeData,
+            sender: string,
+        ): Promise<void> => {
+            // Execute transaction.
+            const txReceipt = await testContract
+                .bridgeTransferFrom(
+                    constants.NULL_ADDRESS,
+                    from,
+                    to,
+                    amount,
+                    dydxBridgeDataEncoder.encode({ bridgeData }),
+                )
+                .awaitTransactionSuccessAsync({ from: sender });
+
+            // Verify `OperateAccount` event.
+            const expectedOperateAccountEvents = [];
+            for (const accountNumber of bridgeData.accountNumbers) {
+                expectedOperateAccountEvents.push({
+                    owner: accountOwner,
+                    number: accountNumber,
+                });
+            }
+            verifyEventsFromLogs(txReceipt.logs, expectedOperateAccountEvents, TestDydxBridgeEvents.OperateAccount);
+
+            // Verify `OperateAction` event.
+            const weiDenomination = 0;
+            const deltaAmountRef = 0;
+            const expectedOperateActionEvents = [];
+            for (const action of bridgeData.actions) {
+                expectedOperateActionEvents.push({
+                    actionType: action.actionType as number,
+                    accountId: action.accountId,
+                    amountSign: action.actionType === DydxBridgeActionType.Deposit ? true : false,
+                    amountDenomination: weiDenomination,
+                    amountRef: deltaAmountRef,
+                    amountValue: action.conversionRateDenominator.gt(0)
+                        ? amount
+                              .times(action.conversionRateNumerator)
+                              .dividedToIntegerBy(action.conversionRateDenominator)
+                        : amount,
+                    primaryMarketId: marketId,
+                    secondaryMarketId: constants.ZERO_AMOUNT,
+                    otherAddress: action.actionType === DydxBridgeActionType.Deposit ? from : to,
+                    otherAccountId: constants.ZERO_AMOUNT,
+                    data: '0x',
+                });
+            }
+            verifyEventsFromLogs(txReceipt.logs, expectedOperateActionEvents, TestDydxBridgeEvents.OperateAction);
+        };
+        it('succeeds when calling with zero amount', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultDepositAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                constants.ZERO_AMOUNT,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling with no accounts', async () => {
+            const bridgeData = {
+                accountNumbers: [],
+                actions: [defaultDepositAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling with no actions', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling `operate` with the `deposit` action and a single account', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultDepositAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling `operate` with the `deposit` action and multiple accounts', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber, defaultAccountNumber.plus(1)],
+                actions: [defaultDepositAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling `operate` with the `withdraw` action and a single account', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultWithdrawAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling `operate` with the `withdraw` action and multiple accounts', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber, defaultAccountNumber.plus(1)],
+                actions: [defaultWithdrawAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling `operate` with the `deposit` action and multiple accounts', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber, defaultAccountNumber.plus(1)],
+                actions: [defaultWithdrawAction, defaultDepositAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling `operate` with multiple actions under a single account', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultWithdrawAction, defaultDepositAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when scaling the `amount` to deposit', async () => {
+            const conversionRateNumerator = new BigNumber(1);
+            const conversionRateDenominator = new BigNumber(2);
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [
+                    defaultWithdrawAction,
+                    {
+                        ...defaultDepositAction,
+                        conversionRateNumerator,
+                        conversionRateDenominator,
+                    },
+                ],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when scaling the `amount` to withdraw', async () => {
+            const conversionRateNumerator = new BigNumber(1);
+            const conversionRateDenominator = new BigNumber(2);
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [
+                    defaultDepositAction,
+                    {
+                        ...defaultWithdrawAction,
+                        conversionRateNumerator,
+                        conversionRateDenominator,
+                    },
+                ],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('reverts if not called by the ERC20 Bridge Proxy', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultDepositAction],
+            };
+            const callBridgeTransferFromPromise = callBridgeTransferFrom(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                notAuthorized,
+            );
+            const expectedError = RevertReason.DydxBridgeOnlyCallableByErc20BridgeProxy;
+            return expect(callBridgeTransferFromPromise).to.revertWith(expectedError);
+        });
+        it('should return magic bytes if call succeeds', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultDepositAction],
+            };
+            const returnValue = await callBridgeTransferFrom(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+            expect(returnValue).to.equal(AssetProxyId.ERC20Bridge);
+        });
+        it('should revert when `Operate` reverts', async () => {
+            // Set revert flag.
+            await testContract.setRevertOnOperate(true).awaitTransactionSuccessAsync();
+
+            // Execute transfer.
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultDepositAction],
+            };
+            const tx = callBridgeTransferFrom(accountOwner, receiver, defaultAmount, bridgeData, authorized);
+            const expectedError = 'TestDydxBridge/SHOULD_REVERT_ON_OPERATE';
+            return expect(tx).to.revertWith(expectedError);
+        });
+        it('should revert when there is a rounding error', async () => {
+            // Setup a rounding error
+            const conversionRateNumerator = new BigNumber(5318);
+            const conversionRateDenominator = new BigNumber(47958);
+            const amount = new BigNumber(9000);
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [
+                    defaultDepositAction,
+                    {
+                        ...defaultWithdrawAction,
+                        conversionRateNumerator,
+                        conversionRateDenominator,
+                    },
+                ],
+            };
+
+            // Execute transfer and assert error.
+            const tx = callBridgeTransferFrom(accountOwner, receiver, amount, bridgeData, authorized);
+            const expectedError = new LibMathRevertErrors.RoundingError(
+                conversionRateNumerator,
+                conversionRateDenominator,
+                amount,
+            );
+            return expect(tx).to.revertWith(expectedError);
+        });
+    });
+
+    describe('ERC20BridgeProxy.transferFrom()', () => {
+        const bridgeData = {
+            accountNumbers: [defaultAccountNumber],
+            actions: [defaultWithdrawAction],
+        };
+        let assetData: string;
+
+        before(async () => {
+            const testTokenAddress = await testContract.getTestToken().callAsync();
+            assetData = assetDataEncoder
+                .ERC20Bridge(testTokenAddress, testContract.address, dydxBridgeDataEncoder.encode({ bridgeData }))
+                .getABIEncodedTransactionData();
+        });
+
+        it('should succeed if `bridgeTransferFrom` succeeds', async () => {
+            await testProxyContract
+                .transferFrom(assetData, accountOwner, receiver, defaultAmount)
+                .awaitTransactionSuccessAsync({ from: authorized });
+        });
+        it('should revert if `bridgeTransferFrom` reverts', async () => {
+            // Set revert flag.
+            await testContract.setRevertOnOperate(true).awaitTransactionSuccessAsync();
+            const tx = testProxyContract
+                .transferFrom(assetData, accountOwner, receiver, defaultAmount)
+                .awaitTransactionSuccessAsync({ from: authorized });
+            const expectedError = 'TestDydxBridge/SHOULD_REVERT_ON_OPERATE';
+            return expect(tx).to.revertWith(expectedError);
+        });
+    });
+});

contracts/asset-proxy/test/erc1155_proxy.ts

@@ -1,3 +1,4 @@
+import { DevUtilsContract } from '@0x/contracts-dev-utils';
 import {
     artifacts as erc1155Artifacts,
     DummyERC1155ReceiverBatchTokenReceivedEventArgs,
@@ -14,16 +15,19 @@ import {
     txDefaults,
     web3Wrapper,
 } from '@0x/contracts-test-utils';
+import { SafeMathRevertErrors } from '@0x/contracts-utils';
 import { BlockchainLifecycle } from '@0x/dev-utils';
-import { assetDataUtils } from '@0x/order-utils';
 import { AssetProxyId, RevertReason } from '@0x/types';
-import { BigNumber, SafeMathRevertErrors } from '@0x/utils';
+import { BigNumber } from '@0x/utils';
 import * as chai from 'chai';
 import { LogWithDecodedArgs } from 'ethereum-types';
 import * as ethUtil from 'ethereumjs-util';
 import * as _ from 'lodash';
 
-import { artifacts, ERC1155ProxyContract, ERC1155ProxyWrapper } from '../src';
+import { ERC1155ProxyWrapper } from '../src/erc1155_proxy_wrapper';
+import { ERC1155ProxyContract, IAssetDataContract } from '../src/wrappers';
+
+import { artifacts } from './artifacts';
 
 chaiSetup.configure();
 const expect = chai.expect;
@@ -59,6 +63,8 @@ describe('ERC1155Proxy', () => {
     // tokens
     let fungibleTokens: BigNumber[];
     let nonFungibleTokensOwnedBySpender: BigNumber[];
+    // devUtils for encoding and decoding assetData
+    let devUtils: DevUtilsContract;
     // tests
     before(async () => {
         await blockchainLifecycle.startAsync();
@@ -72,16 +78,8 @@ describe('ERC1155Proxy', () => {
         const usedAddresses = ([owner, notAuthorized, authorized, spender, receiver] = _.slice(accounts, 0, 5));
         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(
-            erc1155Proxy.address,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await erc1155Proxy.addAuthorizedAddress(authorized).awaitTransactionSuccessAsync({ from: owner });
+        await erc1155Proxy.addAuthorizedAddress(erc1155Proxy.address).awaitTransactionSuccessAsync({ from: owner });
         // deploy & configure ERC1155 tokens and receiver
         [erc1155Wrapper] = await erc1155ProxyWrapper.deployDummyContractsAsync();
         erc1155Contract = erc1155Wrapper.getContract();
@@ -103,6 +101,8 @@ describe('ERC1155Proxy', () => {
                 tokenBalances.nonFungible[spender][erc1155Contract.address][nonFungibleTokenAsString][0];
             nonFungibleTokensOwnedBySpender.push(nonFungibleTokenHeldBySpender);
         });
+        // set up devUtils
+        devUtils = new DevUtilsContract(constants.NULL_ADDRESS, provider, { from: owner });
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
@@ -123,7 +123,7 @@ describe('ERC1155Proxy', () => {
             );
         });
         it('should have an id of 0xa7cb5fb7', async () => {
-            const proxyId = await erc1155Proxy.getProxyId.callAsync();
+            const proxyId = await erc1155Proxy.getProxyId().callAsync();
             const expectedProxyId = AssetProxyId.ERC1155;
             expect(proxyId).to.equal(expectedProxyId);
         });
@@ -638,12 +638,14 @@ describe('ERC1155Proxy', () => {
                 return value.times(valueMultiplier);
             });
             const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
+            const assetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
             const extraData = '0102030405060708091001020304050607080910010203040506070809100102';
             const assetDataWithExtraData = `${assetData}${extraData}`;
             // check balances before transfer
@@ -696,25 +698,20 @@ describe('ERC1155Proxy', () => {
             const tokenUri = '';
             for (const tokenToCreate of tokensToCreate) {
                 // create token
-                await erc1155Wrapper.getContract().createWithType.awaitTransactionSuccessAsync(
-                    tokenToCreate,
-                    tokenUri,
-                    {
+                await erc1155Wrapper
+                    .getContract()
+                    .createWithType(tokenToCreate, tokenUri)
+                    .awaitTransactionSuccessAsync({
                         from: owner,
-                    },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                    });
 
                 // mint balance for spender
-                await erc1155Wrapper.getContract().mintFungible.awaitTransactionSuccessAsync(
-                    tokenToCreate,
-                    [spender],
-                    [spenderInitialBalance],
-                    {
+                await erc1155Wrapper
+                    .getContract()
+                    .mintFungible(tokenToCreate, [spender], [spenderInitialBalance])
+                    .awaitTransactionSuccessAsync({
                         from: owner,
-                    },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                    });
             }
             ///// Step 2/5 /////
             // Check balances before transfer
@@ -747,18 +744,16 @@ describe('ERC1155Proxy', () => {
             const tokensToTransfer = [new BigNumber(1), new BigNumber(2)];
             const valuesToTransfer = tokensToTransfer;
             const valueMultiplier = new BigNumber(2);
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
-            // remove the function selector and contract address from check, as these change on each test
-            const offsetToTokenIds = 74;
-            const assetDataWithoutContractAddress = assetData.substr(offsetToTokenIds);
-            const expectedAssetDataWithoutContractAddress =
+
+            // hand encode optimized assetData because our tooling (based on LibAssetData.sol/encodeERC1155AssetData) does not use optimized encoding
+            const assetDataContract = new IAssetDataContract(constants.NULL_ADDRESS, provider);
+            const selector = assetDataContract.getSelector('ERC1155Assets');
+            const assetDataWithoutContractAddress =
                 '0000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000040102030400000000000000000000000000000000000000000000000000000000';
-            expect(assetDataWithoutContractAddress).to.be.equal(expectedAssetDataWithoutContractAddress);
+            const assetData = `${selector}000000000000000000000000${erc1155ContractAddress.substr(
+                2,
+            )}${assetDataWithoutContractAddress}`;
+
             ///// Step 4/5 /////
             // Transfer token IDs [1, 2] and amounts [1, 2] with a multiplier of 2;
             // the expected trade will be token IDs [1, 2] and amounts [2, 4]
@@ -805,25 +800,20 @@ describe('ERC1155Proxy', () => {
             const tokenUri = '';
             for (const tokenToCreate of tokensToCreate) {
                 // create token
-                await erc1155Wrapper.getContract().createWithType.awaitTransactionSuccessAsync(
-                    tokenToCreate,
-                    tokenUri,
-                    {
+                await erc1155Wrapper
+                    .getContract()
+                    .createWithType(tokenToCreate, tokenUri)
+                    .awaitTransactionSuccessAsync({
                         from: owner,
-                    },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                    });
 
                 // mint balance for spender
-                await erc1155Wrapper.getContract().mintFungible.awaitTransactionSuccessAsync(
-                    tokenToCreate,
-                    [spender],
-                    [spenderInitialBalance],
-                    {
+                await erc1155Wrapper
+                    .getContract()
+                    .mintFungible(tokenToCreate, [spender], [spenderInitialBalance])
+                    .awaitTransactionSuccessAsync({
                         from: owner,
-                    },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                    });
             }
             ///// Step 2/5 /////
             // Check balances before transfer
@@ -867,12 +857,14 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [new BigNumber(2), new BigNumber(2)];
             const valueMultiplier = new BigNumber(2);
             // create callback data that is the encoded version of `valuesToTransfer`
-            const generatedAssetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
+            const generatedAssetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
             // remove the function selector and contract address from check, as these change on each test
             const offsetToTokenIds = 74;
             const assetDataSelectorAndContractAddress = generatedAssetData.substr(0, offsetToTokenIds);
@@ -937,25 +929,20 @@ describe('ERC1155Proxy', () => {
             const tokenUri = '';
             for (const tokenToCreate of tokensToCreate) {
                 // create token
-                await erc1155Wrapper.getContract().createWithType.awaitTransactionSuccessAsync(
-                    tokenToCreate,
-                    tokenUri,
-                    {
+                await erc1155Wrapper
+                    .getContract()
+                    .createWithType(tokenToCreate, tokenUri)
+                    .awaitTransactionSuccessAsync({
                         from: owner,
-                    },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                    });
 
                 // mint balance for spender
-                await erc1155Wrapper.getContract().mintFungible.awaitTransactionSuccessAsync(
-                    tokenToCreate,
-                    [spender],
-                    [spenderInitialBalance],
-                    {
+                await erc1155Wrapper
+                    .getContract()
+                    .mintFungible(tokenToCreate, [spender], [spenderInitialBalance])
+                    .awaitTransactionSuccessAsync({
                         from: owner,
-                    },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                    });
             }
             ///// Step 2/5 /////
             // Check balances before transfer
@@ -996,12 +983,14 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [new BigNumber(1), new BigNumber(2)];
             const valueMultiplier = new BigNumber(2);
             // create callback data that is the encoded version of `valuesToTransfer`
-            const generatedAssetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
+            const generatedAssetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
             // remove the function selector and contract address from check, as these change on each test
             const offsetToTokenIds = 74;
             const assetDataSelectorAndContractAddress = generatedAssetData.substr(0, offsetToTokenIds);
@@ -1059,12 +1048,14 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [fungibleValueToTransferLarge];
             const valueMultiplier = valueMultiplierSmall;
             const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
+            const assetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
             // The asset data we just generated will look like this:
             // a7cb5fb7
             // 0x         0000000000000000000000000b1ba0af832d7c05fd64161e0db78e85978e8082
@@ -1106,12 +1097,14 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [fungibleValueToTransferLarge];
             const valueMultiplier = valueMultiplierSmall;
             const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
+            const assetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
             // The asset data we just generated will look like this:
             // a7cb5fb7
             // 0x         0000000000000000000000000b1ba0af832d7c05fd64161e0db78e85978e8082
@@ -1157,12 +1150,14 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [fungibleValueToTransferLarge];
             const valueMultiplier = valueMultiplierSmall;
             const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
+            const assetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
             // The asset data we just generated will look like this:
             // a7cb5fb7
             // 0x         0000000000000000000000000b1ba0af832d7c05fd64161e0db78e85978e8082
@@ -1208,12 +1203,14 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [fungibleValueToTransferLarge];
             const valueMultiplier = valueMultiplierSmall;
             const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
+            const assetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
             // The asset data we just generated will look like this:
             // a7cb5fb7
             // 0x         0000000000000000000000000b1ba0af832d7c05fd64161e0db78e85978e8082
@@ -1259,12 +1256,14 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [fungibleValueToTransferLarge];
             const valueMultiplier = valueMultiplierSmall;
             const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
+            const assetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
             // The asset data we just generated will look like this:
             // a7cb5fb7
             // 0x         0000000000000000000000000b1ba0af832d7c05fd64161e0db78e85978e8082
@@ -1311,12 +1310,14 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [fungibleValueToTransferLarge];
             const valueMultiplier = valueMultiplierSmall;
             const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
+            const assetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
             // The asset data we just generated will look like this:
             // a7cb5fb7
             // 0x         0000000000000000000000000b1ba0af832d7c05fd64161e0db78e85978e8082
@@ -1358,12 +1359,14 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [fungibleValueToTransferLarge];
             const valueMultiplier = valueMultiplierSmall;
             const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
+            const assetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
             // The asset data we just generated will look like this:
             // a7cb5fb7
             // 0x         0000000000000000000000000b1ba0af832d7c05fd64161e0db78e85978e8082
@@ -1409,12 +1412,14 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [fungibleValueToTransferLarge];
             const valueMultiplier = valueMultiplierSmall;
             const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
+            const assetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
             // The asset data we just generated will look like this:
             // a7cb5fb7
             // 0x         0000000000000000000000000b1ba0af832d7c05fd64161e0db78e85978e8082
@@ -1456,12 +1461,14 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [fungibleValueToTransferLarge];
             const valueMultiplier = valueMultiplierSmall;
             const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
+            const assetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
             // The asset data we just generated will look like this:
             // a7cb5fb7
             // 0x         0000000000000000000000000b1ba0af832d7c05fd64161e0db78e85978e8082
@@ -1507,13 +1514,15 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [fungibleValueToTransferLarge];
             const valueMultiplier = valueMultiplierSmall;
             const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
-            const txData = erc1155ProxyWrapper.getTransferFromAbiEncodedTxData(
+            const assetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
+            const txData = await erc1155ProxyWrapper.getTransferFromAbiEncodedTxDataAsync(
                 spender,
                 receiverContract,
                 erc1155Contract.address,
@@ -1538,13 +1547,15 @@ describe('ERC1155Proxy', () => {
             const valuesToTransfer = [fungibleValueToTransferLarge];
             const valueMultiplier = valueMultiplierSmall;
             const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
-            const txData = erc1155ProxyWrapper.getTransferFromAbiEncodedTxData(
+            const assetData = await devUtils
+                .encodeERC1155AssetData(
+                    erc1155ContractAddress,
+                    tokensToTransfer,
+                    valuesToTransfer,
+                    receiverCallbackData,
+                )
+                .callAsync();
+            const txData = await erc1155ProxyWrapper.getTransferFromAbiEncodedTxDataAsync(
                 spender,
                 receiverContract,
                 erc1155Contract.address,
@@ -1667,13 +1678,9 @@ describe('ERC1155Proxy', () => {
         it('should propagate revert reason from erc1155 contract failure', async () => {
             // disable transfers
             const shouldRejectTransfer = true;
-            await erc1155Receiver.setRejectTransferFlag.awaitTransactionSuccessAsync(
-                shouldRejectTransfer,
-                {
-                    from: owner,
-                },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await erc1155Receiver.setRejectTransferFlag(shouldRejectTransfer).awaitTransactionSuccessAsync({
+                from: owner,
+            });
             // setup test parameters
             const tokenHolders = [spender, receiverContract];
             const tokensToTransfer = fungibleTokens.slice(0, 1);

contracts/asset-proxy/test/erc20bridge_proxy.ts

@@ -3,27 +3,22 @@ import {
     constants,
     expect,
     getRandomInteger,
-    hexLeftPad,
-    hexRightPad,
-    hexSlice,
     Numberish,
     randomAddress,
 } from '@0x/contracts-test-utils';
+import { AuthorizableRevertErrors } from '@0x/contracts-utils';
 import { AssetProxyId } from '@0x/types';
-import { AbiEncoder, AuthorizableRevertErrors, BigNumber, StringRevertError } from '@0x/utils';
+import { AbiEncoder, BigNumber, hexUtils, StringRevertError } from '@0x/utils';
 import { DecodedLogs } from 'ethereum-types';
 import * as _ from 'lodash';
 
-import {
-    artifacts,
-    ERC20BridgeProxyContract,
-    TestERC20BridgeBridgeWithdrawToEventArgs,
-    TestERC20BridgeContract,
-} from '../src';
+import { artifacts } from './artifacts';
+
+import { ERC20BridgeProxyContract, TestERC20BridgeContract } from './wrappers';
 
 blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
     const PROXY_ID = AssetProxyId.ERC20Bridge;
-    const BRIDGE_SUCCESS_RETURN_DATA = hexRightPad(PROXY_ID);
+    const BRIDGE_SUCCESS_RETURN_DATA = hexUtils.rightPad(PROXY_ID);
     let owner: string;
     let badCaller: string;
     let assetProxy: ERC20BridgeProxyContract;
@@ -44,8 +39,8 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
             env.txDefaults,
             artifacts,
         );
-        testTokenAddress = await bridgeContract.testToken.callAsync();
-        await assetProxy.addAuthorizedAddress.awaitTransactionSuccessAsync(owner);
+        testTokenAddress = await bridgeContract.testToken().callAsync();
+        await assetProxy.addAuthorizedAddress(owner).awaitTransactionSuccessAsync();
     });
 
     interface AssetDataOpts {
@@ -102,7 +97,7 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
     }
 
     async function setTestTokenBalanceAsync(_owner: string, balance: Numberish): Promise<void> {
-        await bridgeContract.setTestTokenBalance.awaitTransactionSuccessAsync(_owner, new BigNumber(balance));
+        await bridgeContract.setTestTokenBalance(_owner, new BigNumber(balance)).awaitTransactionSuccessAsync();
     }
 
     describe('transferFrom()', () => {
@@ -132,13 +127,9 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
 
         async function transferFromAsync(opts?: Partial<TransferFromOpts>, caller?: string): Promise<DecodedLogs> {
             const _opts = createTransferFromOpts(opts);
-            const { logs } = await assetProxy.transferFrom.awaitTransactionSuccessAsync(
-                encodeAssetData(_opts.assetData),
-                _opts.from,
-                _opts.to,
-                new BigNumber(_opts.amount),
-                { from: caller },
-            );
+            const { logs } = await assetProxy
+                .transferFrom(encodeAssetData(_opts.assetData), _opts.from, _opts.to, new BigNumber(_opts.amount))
+                .awaitTransactionSuccessAsync({ from: caller });
             return (logs as any) as DecodedLogs;
         }
 
@@ -164,7 +155,7 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
             const opts = createTransferFromOpts();
             const logs = await transferFromAsync(opts);
             expect(logs.length).to.eq(1);
-            const args = logs[0].args as TestERC20BridgeBridgeWithdrawToEventArgs;
+            const args = logs[0].args;
             expect(args.tokenAddress).to.eq(opts.assetData.tokenAddress);
             expect(args.from).to.eq(opts.from);
             expect(args.to).to.eq(opts.to);
@@ -179,13 +170,10 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
 
         it('fails if asset data is truncated', async () => {
             const opts = createTransferFromOpts();
-            const truncatedAssetData = hexSlice(encodeAssetData(opts.assetData), 0, -1);
-            const tx = assetProxy.transferFrom.awaitTransactionSuccessAsync(
-                truncatedAssetData,
-                opts.from,
-                opts.to,
-                new BigNumber(opts.amount),
-            );
+            const truncatedAssetData = hexUtils.slice(encodeAssetData(opts.assetData), 0, -1);
+            const tx = assetProxy
+                .transferFrom(truncatedAssetData, opts.from, opts.to, new BigNumber(opts.amount))
+                .awaitTransactionSuccessAsync();
             return expect(tx).to.be.rejected();
         });
 
@@ -206,7 +194,7 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
             const tx = transferFromAsync({
                 assetData: createAssetData({
                     bridgeData: createBridgeData({
-                        returnData: hexLeftPad('0x1'),
+                        returnData: hexUtils.leftPad('0x1'),
                     }),
                 }),
             });
@@ -219,7 +207,7 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
             const tx = transferFromAsync({
                 assetData: createAssetData({
                     bridgeData: createBridgeData({
-                        returnData: hexRightPad('0x1'),
+                        returnData: hexUtils.rightPad('0x1'),
                     }),
                 }),
             });
@@ -281,18 +269,18 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
         it('retrieves the balance of the encoded token', async () => {
             const _owner = randomAddress();
             const balance = getRandomInteger(1, 100e18);
-            await bridgeContract.setTestTokenBalance.awaitTransactionSuccessAsync(_owner, balance);
+            await bridgeContract.setTestTokenBalance(_owner, balance).awaitTransactionSuccessAsync();
             const assetData = createAssetData({
                 tokenAddress: testTokenAddress,
             });
-            const actualBalance = await assetProxy.balanceOf.callAsync(encodeAssetData(assetData), _owner);
+            const actualBalance = await assetProxy.balanceOf(encodeAssetData(assetData), _owner).callAsync();
             expect(actualBalance).to.bignumber.eq(balance);
         });
     });
 
     describe('getProxyId()', () => {
         it('returns the correct proxy ID', async () => {
-            const proxyId = await assetProxy.getProxyId.callAsync();
+            const proxyId = await assetProxy.getProxyId().callAsync();
             expect(proxyId).to.eq(PROXY_ID);
         });
     });

contracts/asset-proxy/test/eth2dai_bridge.ts

@@ -4,28 +4,25 @@ import {
     expect,
     filterLogsToArguments,
     getRandomInteger,
-    hexLeftPad,
-    hexRandom,
     Numberish,
     randomAddress,
-    TransactionHelper,
 } from '@0x/contracts-test-utils';
 import { AssetProxyId } from '@0x/types';
-import { BigNumber } from '@0x/utils';
+import { BigNumber, hexUtils, RawRevertError } from '@0x/utils';
 import { DecodedLogs } from 'ethereum-types';
 import * as _ from 'lodash';
 
+import { artifacts } from './artifacts';
+
 import {
-    artifacts,
     TestEth2DaiBridgeContract,
     TestEth2DaiBridgeEvents,
     TestEth2DaiBridgeSellAllAmountEventArgs,
     TestEth2DaiBridgeTokenApproveEventArgs,
     TestEth2DaiBridgeTokenTransferEventArgs,
-} from '../src';
+} from './wrappers';
 
 blockchainTests.resets('Eth2DaiBridge unit tests', env => {
-    const txHelper = new TransactionHelper(env.web3Wrapper, artifacts);
     let testContract: TestEth2DaiBridgeContract;
 
     before(async () => {
@@ -40,12 +37,14 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
     describe('isValidSignature()', () => {
         it('returns success bytes', async () => {
             const LEGACY_WALLET_MAGIC_VALUE = '0xb0671381';
-            const result = await testContract.isValidSignature.callAsync(hexRandom(), hexRandom(_.random(0, 32)));
+            const result = await testContract
+                .isValidSignature(hexUtils.random(), hexUtils.random(_.random(0, 32)))
+                .callAsync();
             expect(result).to.eq(LEGACY_WALLET_MAGIC_VALUE);
         });
     });
 
-    describe('withdrawTo()', () => {
+    describe('bridgeTransferFrom()', () => {
         interface WithdrawToOpts {
             toTokenAddress?: string;
             fromTokenAddress?: string;
@@ -72,7 +71,7 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
                 fillAmount: getRandomInteger(1, 100e18),
                 fromTokenBalance: getRandomInteger(1, 100e18),
                 toTokentransferRevertReason: '',
-                toTokenTransferReturnData: hexLeftPad(1),
+                toTokenTransferReturnData: hexUtils.leftPad(1),
                 ...opts,
             };
         }
@@ -80,32 +79,30 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
         async function withdrawToAsync(opts?: Partial<WithdrawToOpts>): Promise<WithdrawToResult> {
             const _opts = createWithdrawToOpts(opts);
             // Set the fill behavior.
-            await testContract.setFillBehavior.awaitTransactionSuccessAsync(
-                _opts.revertReason,
-                new BigNumber(_opts.fillAmount),
-            );
+            await testContract
+                .setFillBehavior(_opts.revertReason, new BigNumber(_opts.fillAmount))
+                .awaitTransactionSuccessAsync();
             // Create tokens and balances.
             if (_opts.fromTokenAddress === undefined) {
-                [_opts.fromTokenAddress] = await txHelper.getResultAndReceiptAsync(
-                    testContract.createToken,
-                    new BigNumber(_opts.fromTokenBalance),
-                );
+                const createTokenFn = testContract.createToken(new BigNumber(_opts.fromTokenBalance));
+                _opts.fromTokenAddress = await createTokenFn.callAsync();
+                await createTokenFn.awaitTransactionSuccessAsync();
             }
             if (_opts.toTokenAddress === undefined) {
-                [_opts.toTokenAddress] = await txHelper.getResultAndReceiptAsync(
-                    testContract.createToken,
-                    constants.ZERO_AMOUNT,
-                );
+                const createTokenFn = testContract.createToken(constants.ZERO_AMOUNT);
+                _opts.toTokenAddress = await createTokenFn.callAsync();
+                await createTokenFn.awaitTransactionSuccessAsync();
             }
             // Set the transfer behavior of `toTokenAddress`.
-            await testContract.setTransferBehavior.awaitTransactionSuccessAsync(
-                _opts.toTokenAddress,
-                _opts.toTokentransferRevertReason,
-                _opts.toTokenTransferReturnData,
-            );
-            // Call withdrawTo().
-            const [result, { logs }] = await txHelper.getResultAndReceiptAsync(
-                testContract.withdrawTo,
+            await testContract
+                .setTransferBehavior(
+                    _opts.toTokenAddress,
+                    _opts.toTokentransferRevertReason,
+                    _opts.toTokenTransferReturnData,
+                )
+                .awaitTransactionSuccessAsync();
+            // Call bridgeTransferFrom().
+            const bridgeTransferFromFn = testContract.bridgeTransferFrom(
                 // "to" token address
                 _opts.toTokenAddress,
                 // Random from address.
@@ -114,8 +111,10 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
                 _opts.toAddress,
                 new BigNumber(_opts.amount),
                 // ABI-encode the "from" token address as the bridge data.
-                hexLeftPad(_opts.fromTokenAddress as string),
+                hexUtils.leftPad(_opts.fromTokenAddress as string),
             );
+            const result = await bridgeTransferFromFn.callAsync();
+            const { logs } = await bridgeTransferFromFn.awaitTransactionSuccessAsync();
             return {
                 opts: _opts,
                 result,
@@ -179,14 +178,14 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
             return expect(tx).to.revertWith(opts.toTokentransferRevertReason);
         });
 
-        it('fails if `toTokenAddress.transfer()` returns falsey', async () => {
-            const opts = createWithdrawToOpts({ toTokenTransferReturnData: hexLeftPad(0) });
+        it('fails if `toTokenAddress.transfer()` returns false', async () => {
+            const opts = createWithdrawToOpts({ toTokenTransferReturnData: hexUtils.leftPad(0) });
             const tx = withdrawToAsync(opts);
-            return expect(tx).to.revertWith('ERC20_TRANSFER_FAILED');
+            return expect(tx).to.revertWith(new RawRevertError(hexUtils.leftPad(0)));
         });
 
-        it('succeeds if `toTokenAddress.transfer()` returns truthy', async () => {
-            await withdrawToAsync({ toTokenTransferReturnData: hexLeftPad(100) });
+        it('succeeds if `toTokenAddress.transfer()` returns true', async () => {
+            await withdrawToAsync({ toTokenTransferReturnData: hexUtils.leftPad(1) });
         });
     });
 });

contracts/asset-proxy/test/kyber_bridge.ts

@@ -0,0 +1,283 @@
+import {
+    blockchainTests,
+    constants,
+    expect,
+    getRandomInteger,
+    getRandomPortion,
+    randomAddress,
+    verifyEventsFromLogs,
+} from '@0x/contracts-test-utils';
+import { AssetProxyId } from '@0x/types';
+import { BigNumber, hexUtils } from '@0x/utils';
+import { DecodedLogs } from 'ethereum-types';
+import * as _ from 'lodash';
+
+import { artifacts } from './artifacts';
+
+import { TestKyberBridgeContract, TestKyberBridgeEvents } from './wrappers';
+
+blockchainTests.resets('KyberBridge unit tests', env => {
+    const KYBER_ETH_ADDRESS = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+    const FROM_TOKEN_DECIMALS = 6;
+    const TO_TOKEN_DECIMALS = 18;
+    const FROM_TOKEN_BASE = new BigNumber(10).pow(FROM_TOKEN_DECIMALS);
+    const TO_TOKEN_BASE = new BigNumber(10).pow(TO_TOKEN_DECIMALS);
+    const WETH_BASE = new BigNumber(10).pow(18);
+    const KYBER_RATE_BASE = WETH_BASE;
+    let testContract: TestKyberBridgeContract;
+
+    before(async () => {
+        testContract = await TestKyberBridgeContract.deployFrom0xArtifactAsync(
+            artifacts.TestKyberBridge,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+        );
+    });
+
+    describe('isValidSignature()', () => {
+        it('returns success bytes', async () => {
+            const LEGACY_WALLET_MAGIC_VALUE = '0xb0671381';
+            const result = await testContract
+                .isValidSignature(hexUtils.random(), hexUtils.random(_.random(0, 32)))
+                .callAsync();
+            expect(result).to.eq(LEGACY_WALLET_MAGIC_VALUE);
+        });
+    });
+
+    describe('bridgeTransferFrom()', () => {
+        let fromTokenAddress: string;
+        let toTokenAddress: string;
+        let wethAddress: string;
+
+        before(async () => {
+            wethAddress = await testContract.weth().callAsync();
+            fromTokenAddress = await testContract.createToken(FROM_TOKEN_DECIMALS).callAsync();
+            await testContract.createToken(FROM_TOKEN_DECIMALS).awaitTransactionSuccessAsync();
+            toTokenAddress = await testContract.createToken(TO_TOKEN_DECIMALS).callAsync();
+            await testContract.createToken(TO_TOKEN_DECIMALS).awaitTransactionSuccessAsync();
+        });
+
+        const STATIC_KYBER_TRADE_ARGS = {
+            maxBuyTokenAmount: constants.MAX_UINT256,
+            walletId: constants.NULL_ADDRESS,
+        };
+
+        interface TransferFromOpts {
+            toTokenAddress: string;
+            fromTokenAddress: string;
+            toAddress: string;
+            // Amount to pass into `bridgeTransferFrom()`
+            amount: BigNumber;
+            // Amount to convert in `trade()`.
+            fillAmount: BigNumber;
+            // Token balance of the bridge.
+            fromTokenBalance: BigNumber;
+        }
+
+        interface TransferFromResult {
+            opts: TransferFromOpts;
+            result: string;
+            logs: DecodedLogs;
+        }
+
+        function createTransferFromOpts(opts?: Partial<TransferFromOpts>): TransferFromOpts {
+            const amount = getRandomInteger(1, TO_TOKEN_BASE.times(100));
+            return {
+                fromTokenAddress,
+                toTokenAddress,
+                amount,
+                toAddress: randomAddress(),
+                fillAmount: getRandomPortion(amount),
+                fromTokenBalance: getRandomInteger(1, FROM_TOKEN_BASE.times(100)),
+                ...opts,
+            };
+        }
+
+        async function withdrawToAsync(opts?: Partial<TransferFromOpts>): Promise<TransferFromResult> {
+            const _opts = createTransferFromOpts(opts);
+            // Fund the contract with input tokens.
+            await testContract
+                .grantTokensTo(_opts.fromTokenAddress, testContract.address, _opts.fromTokenBalance)
+                .awaitTransactionSuccessAsync({ value: _opts.fromTokenBalance });
+            // Fund the contract with output tokens.
+            await testContract.setNextFillAmount(_opts.fillAmount).awaitTransactionSuccessAsync({
+                value: _opts.toTokenAddress === wethAddress ? _opts.fillAmount : constants.ZERO_AMOUNT,
+            });
+            // Call bridgeTransferFrom().
+            const bridgeTransferFromFn = testContract.bridgeTransferFrom(
+                // Output token
+                _opts.toTokenAddress,
+                // Random maker address.
+                randomAddress(),
+                // Recipient address.
+                _opts.toAddress,
+                // Transfer amount.
+                _opts.amount,
+                // ABI-encode the input token address as the bridge data.
+                hexUtils.leftPad(_opts.fromTokenAddress),
+            );
+            const result = await bridgeTransferFromFn.callAsync();
+            const { logs } = await bridgeTransferFromFn.awaitTransactionSuccessAsync();
+            return {
+                opts: _opts,
+                result,
+                logs: (logs as any) as DecodedLogs,
+            };
+        }
+
+        function getMinimumConversionRate(opts: TransferFromOpts): BigNumber {
+            const fromBase = opts.fromTokenAddress === wethAddress ? WETH_BASE : FROM_TOKEN_BASE;
+            const toBase = opts.toTokenAddress === wethAddress ? WETH_BASE : TO_TOKEN_BASE;
+            return opts.amount
+                .div(toBase)
+                .div(opts.fromTokenBalance.div(fromBase))
+                .times(KYBER_RATE_BASE)
+                .integerValue(BigNumber.ROUND_DOWN);
+        }
+
+        it('returns magic bytes on success', async () => {
+            const BRIDGE_SUCCESS_RETURN_DATA = AssetProxyId.ERC20Bridge;
+            const { result } = await withdrawToAsync();
+            expect(result).to.eq(BRIDGE_SUCCESS_RETURN_DATA);
+        });
+
+        it('can trade token -> token', async () => {
+            const { opts, logs } = await withdrawToAsync();
+            verifyEventsFromLogs(
+                logs,
+                [
+                    {
+                        sellTokenAddress: opts.fromTokenAddress,
+                        buyTokenAddress: opts.toTokenAddress,
+                        sellAmount: opts.fromTokenBalance,
+                        recipientAddress: opts.toAddress,
+                        minConversionRate: getMinimumConversionRate(opts),
+                        msgValue: constants.ZERO_AMOUNT,
+                        ...STATIC_KYBER_TRADE_ARGS,
+                    },
+                ],
+                TestKyberBridgeEvents.KyberBridgeTrade,
+            );
+        });
+
+        it('can trade token -> ETH', async () => {
+            const { opts, logs } = await withdrawToAsync({
+                toTokenAddress: wethAddress,
+            });
+            verifyEventsFromLogs(
+                logs,
+                [
+                    {
+                        sellTokenAddress: opts.fromTokenAddress,
+                        buyTokenAddress: KYBER_ETH_ADDRESS,
+                        sellAmount: opts.fromTokenBalance,
+                        recipientAddress: testContract.address,
+                        minConversionRate: getMinimumConversionRate(opts),
+                        msgValue: constants.ZERO_AMOUNT,
+                        ...STATIC_KYBER_TRADE_ARGS,
+                    },
+                ],
+                TestKyberBridgeEvents.KyberBridgeTrade,
+            );
+        });
+
+        it('can trade ETH -> token', async () => {
+            const { opts, logs } = await withdrawToAsync({
+                fromTokenAddress: wethAddress,
+            });
+            verifyEventsFromLogs(
+                logs,
+                [
+                    {
+                        sellTokenAddress: KYBER_ETH_ADDRESS,
+                        buyTokenAddress: opts.toTokenAddress,
+                        sellAmount: opts.fromTokenBalance,
+                        recipientAddress: opts.toAddress,
+                        minConversionRate: getMinimumConversionRate(opts),
+                        msgValue: opts.fromTokenBalance,
+                        ...STATIC_KYBER_TRADE_ARGS,
+                    },
+                ],
+                TestKyberBridgeEvents.KyberBridgeTrade,
+            );
+        });
+
+        it('does nothing if bridge has no token balance', async () => {
+            const { logs } = await withdrawToAsync({
+                fromTokenBalance: constants.ZERO_AMOUNT,
+            });
+            expect(logs).to.be.length(0);
+        });
+
+        it('only transfers the token if trading the same token', async () => {
+            const { opts, logs } = await withdrawToAsync({
+                toTokenAddress: fromTokenAddress,
+            });
+            verifyEventsFromLogs(
+                logs,
+                [
+                    {
+                        tokenAddress: fromTokenAddress,
+                        ownerAddress: testContract.address,
+                        recipientAddress: opts.toAddress,
+                        amount: opts.fromTokenBalance,
+                    },
+                ],
+                TestKyberBridgeEvents.KyberBridgeTokenTransfer,
+            );
+        });
+
+        it('grants Kyber an allowance when selling non-WETH', async () => {
+            const { opts, logs } = await withdrawToAsync();
+            verifyEventsFromLogs(
+                logs,
+                [
+                    {
+                        tokenAddress: opts.fromTokenAddress,
+                        ownerAddress: testContract.address,
+                        spenderAddress: testContract.address,
+                        allowance: constants.MAX_UINT256,
+                    },
+                ],
+                TestKyberBridgeEvents.KyberBridgeTokenApprove,
+            );
+        });
+
+        it('does not grant Kyber an allowance when selling WETH', async () => {
+            const { logs } = await withdrawToAsync({
+                fromTokenAddress: wethAddress,
+            });
+            verifyEventsFromLogs(logs, [], TestKyberBridgeEvents.KyberBridgeTokenApprove);
+        });
+
+        it('withdraws WETH and passes it to Kyber when selling WETH', async () => {
+            const { opts, logs } = await withdrawToAsync({
+                fromTokenAddress: wethAddress,
+            });
+            expect(logs[0].event).to.eq(TestKyberBridgeEvents.KyberBridgeWethWithdraw);
+            expect(logs[0].args).to.deep.eq({
+                ownerAddress: testContract.address,
+                amount: opts.fromTokenBalance,
+            });
+            expect(logs[1].event).to.eq(TestKyberBridgeEvents.KyberBridgeTrade);
+            expect(logs[1].args.msgValue).to.bignumber.eq(opts.fromTokenBalance);
+        });
+
+        it('wraps WETH and transfers it to the recipient when buyng WETH', async () => {
+            const { opts, logs } = await withdrawToAsync({
+                toTokenAddress: wethAddress,
+            });
+            expect(logs[0].event).to.eq(TestKyberBridgeEvents.KyberBridgeTokenApprove);
+            expect(logs[0].args.tokenAddress).to.eq(opts.fromTokenAddress);
+            expect(logs[1].event).to.eq(TestKyberBridgeEvents.KyberBridgeTrade);
+            expect(logs[1].args.recipientAddress).to.eq(testContract.address);
+            expect(logs[2].event).to.eq(TestKyberBridgeEvents.KyberBridgeWethDeposit);
+            expect(logs[2].args).to.deep.eq({
+                msgValue: opts.fillAmount,
+                ownerAddress: testContract.address,
+                amount: opts.fillAmount,
+            });
+        });
+    });
+});

contracts/asset-proxy/test/static_call_proxy.ts

@@ -1,3 +1,4 @@
+import { DevUtilsContract } from '@0x/contracts-dev-utils';
 import {
     chaiSetup,
     constants,
@@ -8,13 +9,14 @@ import {
     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';
+import { artifacts } from './artifacts';
+
+import { IAssetProxyContract, StaticCallProxyContract, TestStaticCallTargetContract } from './wrappers';
 
 chaiSetup.configure();
 const expect = chai.expect;
@@ -25,6 +27,7 @@ describe('StaticCallProxy', () => {
     let fromAddress: string;
     let toAddress: string;
 
+    let devUtils: DevUtilsContract;
     let staticCallProxy: IAssetProxyContract;
     let staticCallTarget: TestStaticCallTargetContract;
 
@@ -43,6 +46,7 @@ describe('StaticCallProxy', () => {
             txDefaults,
             artifacts,
         );
+        devUtils = new DevUtilsContract(constants.NULL_ADDRESS, provider);
         staticCallProxy = new IAssetProxyContract(
             staticCallProxyWithoutTransferFrom.address,
             provider,
@@ -77,26 +81,21 @@ describe('StaticCallProxy', () => {
             );
         });
         it('should have an id of 0xc339d10a', async () => {
-            const proxyId = await staticCallProxy.getProxyId.callAsync();
+            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 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 assetData = await devUtils
+                .encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
+                .callAsync();
+            const txData = staticCallProxy
+                .transferFrom(assetData, fromAddress, toAddress, amount)
+                .getABIEncodedTransactionData();
             const offsetToAssetData = '0000000000000000000000000000000000000000000000000000000000000080';
             const txDataEndBuffer = ethUtil.toBuffer((txData.length - 2) / 2 - 4);
             const paddedTxDataEndBuffer = ethUtil.setLengthLeft(txDataEndBuffer, 32);
@@ -114,23 +113,21 @@ describe('StaticCallProxy', () => {
         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
+            const assetData = (await devUtils
                 .encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
-                .slice(0, -128);
+                .callAsync()).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),
+                staticCallProxy.transferFrom(assetData, fromAddress, toAddress, amount).sendTransactionAsync(),
             );
         });
         it('should revert if the offset to `staticCallData` points to outside of assetData', async () => {
-            const staticCallData = staticCallTarget.noInputFunction.getABIEncodedTransactionData();
+            const staticCallData = staticCallTarget.noInputFunction().getABIEncodedTransactionData();
             const expectedResultHash = constants.KECCAK256_NULL;
-            const assetData = assetDataUtils.encodeStaticCallAssetData(
-                staticCallTarget.address,
-                staticCallData,
-                expectedResultHash,
-            );
+            const assetData = await devUtils
+                .encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
+                .callAsync();
             const offsetToStaticCallData = '0000000000000000000000000000000000000000000000000000000000000060';
             const assetDataEndBuffer = ethUtil.toBuffer((assetData.length - 2) / 2 - 4);
             const paddedAssetDataEndBuffer = ethUtil.setLengthLeft(assetDataEndBuffer, 32);
@@ -141,90 +138,88 @@ describe('StaticCallProxy', () => {
                 invalidOffsetToStaticCallData,
             )}${newStaticCallData}`;
             await expectTransactionFailedWithoutReasonAsync(
-                staticCallProxy.transferFrom.sendTransactionAsync(badAssetData, fromAddress, toAddress, amount),
+                staticCallProxy.transferFrom(badAssetData, fromAddress, toAddress, amount).sendTransactionAsync(),
             );
         });
         it('should revert if the callTarget attempts to write to state', async () => {
-            const staticCallData = staticCallTarget.updateState.getABIEncodedTransactionData();
+            const staticCallData = staticCallTarget.updateState().getABIEncodedTransactionData();
             const expectedResultHash = constants.KECCAK256_NULL;
-            const assetData = assetDataUtils.encodeStaticCallAssetData(
-                staticCallTarget.address,
-                staticCallData,
-                expectedResultHash,
-            );
+            const assetData = await devUtils
+                .encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
+                .callAsync();
             await expectTransactionFailedWithoutReasonAsync(
-                staticCallProxy.transferFrom.sendTransactionAsync(assetData, fromAddress, toAddress, amount),
+                staticCallProxy.transferFrom(assetData, fromAddress, toAddress, amount).sendTransactionAsync(),
             );
         });
         it('should revert with data provided by the callTarget if the staticcall reverts', async () => {
-            const staticCallData = staticCallTarget.assertEvenNumber.getABIEncodedTransactionData(new BigNumber(1));
+            const staticCallData = staticCallTarget.assertEvenNumber(new BigNumber(1)).getABIEncodedTransactionData();
             const expectedResultHash = constants.KECCAK256_NULL;
-            const assetData = assetDataUtils.encodeStaticCallAssetData(
-                staticCallTarget.address,
-                staticCallData,
-                expectedResultHash,
-            );
+            const assetData = await devUtils
+                .encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
+                .callAsync();
             await expectTransactionFailedAsync(
-                staticCallProxy.transferFrom.sendTransactionAsync(assetData, fromAddress, toAddress, amount),
+                staticCallProxy.transferFrom(assetData, fromAddress, toAddress, amount).sendTransactionAsync(),
                 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 staticCallData = staticCallTarget.isOddNumber(new BigNumber(0)).getABIEncodedTransactionData();
             const trueAsBuffer = ethUtil.toBuffer('0x0000000000000000000000000000000000000000000000000000000000000001');
             const expectedResultHash = ethUtil.bufferToHex(ethUtil.sha3(trueAsBuffer));
-            const assetData = assetDataUtils.encodeStaticCallAssetData(
-                staticCallTarget.address,
-                staticCallData,
-                expectedResultHash,
-            );
+            const assetData = await devUtils
+                .encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
+                .callAsync();
             await expectTransactionFailedAsync(
-                staticCallProxy.transferFrom.sendTransactionAsync(assetData, fromAddress, toAddress, amount),
+                staticCallProxy.transferFrom(assetData, fromAddress, toAddress, amount).sendTransactionAsync(),
                 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 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);
+            const assetData = await devUtils
+                .encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
+                .callAsync();
+            await staticCallProxy
+                .transferFrom(assetData, fromAddress, toAddress, amount)
+                .awaitTransactionSuccessAsync();
         });
         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);
+            const assetData = await devUtils
+                .encodeStaticCallAssetData(toAddress, staticCallData, expectedResultHash)
+                .callAsync();
+            await staticCallProxy
+                .transferFrom(assetData, fromAddress, toAddress, amount)
+                .awaitTransactionSuccessAsync();
         });
         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 staticCallData = staticCallTarget.isOddNumber(new BigNumber(1)).getABIEncodedTransactionData();
             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);
+            const assetData = await devUtils
+                .encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
+                .callAsync();
+            await staticCallProxy
+                .transferFrom(assetData, fromAddress, toAddress, amount)
+                .awaitTransactionSuccessAsync();
         });
         it('should be successful if a function with one dynamic input is successful', async () => {
             const dynamicInput = '0x0102030405060708';
-            const staticCallData = staticCallTarget.dynamicInputFunction.getABIEncodedTransactionData(dynamicInput);
+            const staticCallData = staticCallTarget.dynamicInputFunction(dynamicInput).getABIEncodedTransactionData();
             const expectedResultHash = constants.KECCAK256_NULL;
-            const assetData = assetDataUtils.encodeStaticCallAssetData(
-                staticCallTarget.address,
-                staticCallData,
-                expectedResultHash,
-            );
-            await staticCallProxy.transferFrom.awaitTransactionSuccessAsync(assetData, fromAddress, toAddress, amount);
+            const assetData = await devUtils
+                .encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
+                .callAsync();
+            await staticCallProxy
+                .transferFrom(assetData, fromAddress, toAddress, amount)
+                .awaitTransactionSuccessAsync();
         });
         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 staticCallData = staticCallTarget.returnComplexType(a, b).getABIEncodedTransactionData();
             const abiEncoder = new AbiEncoder.DynamicBytes({
                 name: '',
                 type: 'bytes',
@@ -237,12 +232,12 @@ describe('StaticCallProxy', () => {
             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);
+            const assetData = await devUtils
+                .encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
+                .callAsync();
+            await staticCallProxy
+                .transferFrom(assetData, fromAddress, toAddress, amount)
+                .awaitTransactionSuccessAsync();
         });
     });
 });

contracts/asset-proxy/test/uniswap_bridge.ts

@@ -0,0 +1,370 @@
+import {
+    blockchainTests,
+    constants,
+    expect,
+    filterLogs,
+    filterLogsToArguments,
+    getRandomInteger,
+    Numberish,
+    randomAddress,
+} from '@0x/contracts-test-utils';
+import { AssetProxyId } from '@0x/types';
+import { BigNumber, hexUtils } from '@0x/utils';
+import { DecodedLogs } from 'ethereum-types';
+import * as _ from 'lodash';
+
+import { artifacts } from './artifacts';
+
+import {
+    TestUniswapBridgeContract,
+    TestUniswapBridgeEthToTokenTransferInputEventArgs as EthToTokenTransferInputArgs,
+    TestUniswapBridgeEvents as ContractEvents,
+    TestUniswapBridgeTokenApproveEventArgs as TokenApproveArgs,
+    TestUniswapBridgeTokenToEthSwapInputEventArgs as TokenToEthSwapInputArgs,
+    TestUniswapBridgeTokenToTokenTransferInputEventArgs as TokenToTokenTransferInputArgs,
+    TestUniswapBridgeTokenTransferEventArgs as TokenTransferArgs,
+    TestUniswapBridgeWethDepositEventArgs as WethDepositArgs,
+    TestUniswapBridgeWethWithdrawEventArgs as WethWithdrawArgs,
+} from './wrappers';
+
+blockchainTests.resets('UniswapBridge unit tests', env => {
+    let testContract: TestUniswapBridgeContract;
+    let wethTokenAddress: string;
+
+    before(async () => {
+        testContract = await TestUniswapBridgeContract.deployFrom0xArtifactAsync(
+            artifacts.TestUniswapBridge,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+        );
+        wethTokenAddress = await testContract.wethToken().callAsync();
+    });
+
+    describe('isValidSignature()', () => {
+        it('returns success bytes', async () => {
+            const LEGACY_WALLET_MAGIC_VALUE = '0xb0671381';
+            const result = await testContract
+                .isValidSignature(hexUtils.random(), hexUtils.random(_.random(0, 32)))
+                .callAsync();
+            expect(result).to.eq(LEGACY_WALLET_MAGIC_VALUE);
+        });
+    });
+
+    describe('bridgeTransferFrom()', () => {
+        interface WithdrawToOpts {
+            fromTokenAddress: string;
+            toTokenAddress: string;
+            fromTokenBalance: Numberish;
+            toAddress: string;
+            amount: Numberish;
+            exchangeRevertReason: string;
+            exchangeFillAmount: Numberish;
+            toTokenRevertReason: string;
+            fromTokenRevertReason: string;
+        }
+
+        function createWithdrawToOpts(opts?: Partial<WithdrawToOpts>): WithdrawToOpts {
+            return {
+                fromTokenAddress: constants.NULL_ADDRESS,
+                toTokenAddress: constants.NULL_ADDRESS,
+                fromTokenBalance: getRandomInteger(1, 1e18),
+                toAddress: randomAddress(),
+                amount: getRandomInteger(1, 1e18),
+                exchangeRevertReason: '',
+                exchangeFillAmount: getRandomInteger(1, 1e18),
+                toTokenRevertReason: '',
+                fromTokenRevertReason: '',
+                ...opts,
+            };
+        }
+
+        interface WithdrawToResult {
+            opts: WithdrawToOpts;
+            result: string;
+            logs: DecodedLogs;
+            blockTime: number;
+        }
+
+        async function withdrawToAsync(opts?: Partial<WithdrawToOpts>): Promise<WithdrawToResult> {
+            const _opts = createWithdrawToOpts(opts);
+            const callData = { value: new BigNumber(_opts.exchangeFillAmount) };
+            // Create the "from" token and exchange.
+            const createFromTokenFn = testContract.createTokenAndExchange(
+                _opts.fromTokenAddress,
+                _opts.exchangeRevertReason,
+            );
+            [_opts.fromTokenAddress] = await createFromTokenFn.callAsync(callData);
+            await createFromTokenFn.awaitTransactionSuccessAsync(callData);
+
+            // Create the "to" token and exchange.
+            const createToTokenFn = testContract.createTokenAndExchange(
+                _opts.toTokenAddress,
+                _opts.exchangeRevertReason,
+            );
+            [_opts.toTokenAddress] = await createToTokenFn.callAsync(callData);
+            await createToTokenFn.awaitTransactionSuccessAsync(callData);
+
+            await testContract
+                .setTokenRevertReason(_opts.toTokenAddress, _opts.toTokenRevertReason)
+                .awaitTransactionSuccessAsync();
+            await testContract
+                .setTokenRevertReason(_opts.fromTokenAddress, _opts.fromTokenRevertReason)
+                .awaitTransactionSuccessAsync();
+            // Set the token balance for the token we're converting from.
+            await testContract.setTokenBalance(_opts.fromTokenAddress).awaitTransactionSuccessAsync({
+                value: new BigNumber(_opts.fromTokenBalance),
+            });
+            // Call bridgeTransferFrom().
+            const bridgeTransferFromFn = testContract.bridgeTransferFrom(
+                // The "to" token address.
+                _opts.toTokenAddress,
+                // The "from" address.
+                randomAddress(),
+                // The "to" address.
+                _opts.toAddress,
+                // The amount to transfer to "to"
+                new BigNumber(_opts.amount),
+                // ABI-encoded "from" token address.
+                hexUtils.leftPad(_opts.fromTokenAddress),
+            );
+            const result = await bridgeTransferFromFn.callAsync();
+            const receipt = await bridgeTransferFromFn.awaitTransactionSuccessAsync();
+            return {
+                opts: _opts,
+                result,
+                logs: (receipt.logs as any) as DecodedLogs,
+                blockTime: await env.web3Wrapper.getBlockTimestampAsync(receipt.blockNumber),
+            };
+        }
+
+        async function getExchangeForTokenAsync(tokenAddress: string): Promise<string> {
+            return testContract.getExchange(tokenAddress).callAsync();
+        }
+
+        it('returns magic bytes on success', async () => {
+            const { result } = await withdrawToAsync();
+            expect(result).to.eq(AssetProxyId.ERC20Bridge);
+        });
+
+        it('just transfers tokens to `to` if the same tokens are in play', async () => {
+            const createTokenFn = await testContract.createTokenAndExchange(constants.NULL_ADDRESS, '');
+            const [tokenAddress] = await createTokenFn.callAsync();
+            await createTokenFn.awaitTransactionSuccessAsync();
+            const { opts, result, logs } = await withdrawToAsync({
+                fromTokenAddress: tokenAddress,
+                toTokenAddress: tokenAddress,
+            });
+            expect(result).to.eq(AssetProxyId.ERC20Bridge);
+            const transfers = filterLogsToArguments<TokenTransferArgs>(logs, ContractEvents.TokenTransfer);
+            expect(transfers.length).to.eq(1);
+            expect(transfers[0].token).to.eq(tokenAddress);
+            expect(transfers[0].from).to.eq(testContract.address);
+            expect(transfers[0].to).to.eq(opts.toAddress);
+            expect(transfers[0].amount).to.bignumber.eq(opts.amount);
+        });
+
+        describe('token -> token', () => {
+            it('calls `IUniswapExchange.tokenToTokenTransferInput()', async () => {
+                const { opts, logs, blockTime } = await withdrawToAsync();
+                const exchangeAddress = await getExchangeForTokenAsync(opts.fromTokenAddress);
+                const calls = filterLogsToArguments<TokenToTokenTransferInputArgs>(
+                    logs,
+                    ContractEvents.TokenToTokenTransferInput,
+                );
+                expect(calls.length).to.eq(1);
+                expect(calls[0].exchange).to.eq(exchangeAddress);
+                expect(calls[0].tokensSold).to.bignumber.eq(opts.fromTokenBalance);
+                expect(calls[0].minTokensBought).to.bignumber.eq(opts.amount);
+                expect(calls[0].minEthBought).to.bignumber.eq(1);
+                expect(calls[0].deadline).to.bignumber.eq(blockTime);
+                expect(calls[0].recipient).to.eq(opts.toAddress);
+                expect(calls[0].toTokenAddress).to.eq(opts.toTokenAddress);
+            });
+
+            it('sets allowance for "from" token', async () => {
+                const { opts, logs } = await withdrawToAsync();
+                const approvals = filterLogsToArguments<TokenApproveArgs>(logs, ContractEvents.TokenApprove);
+                const exchangeAddress = await getExchangeForTokenAsync(opts.fromTokenAddress);
+                expect(approvals.length).to.eq(1);
+                expect(approvals[0].spender).to.eq(exchangeAddress);
+                expect(approvals[0].allowance).to.bignumber.eq(constants.MAX_UINT256);
+            });
+
+            it('sets allowance for "from" token on subsequent calls', async () => {
+                const { opts } = await withdrawToAsync();
+                const { logs } = await withdrawToAsync(opts);
+                const approvals = filterLogsToArguments<TokenApproveArgs>(logs, ContractEvents.TokenApprove);
+                const exchangeAddress = await getExchangeForTokenAsync(opts.fromTokenAddress);
+                expect(approvals.length).to.eq(1);
+                expect(approvals[0].spender).to.eq(exchangeAddress);
+                expect(approvals[0].allowance).to.bignumber.eq(constants.MAX_UINT256);
+            });
+
+            it('fails if "from" token does not exist', async () => {
+                const tx = testContract
+                    .bridgeTransferFrom(
+                        randomAddress(),
+                        randomAddress(),
+                        randomAddress(),
+                        getRandomInteger(1, 1e18),
+                        hexUtils.leftPad(randomAddress()),
+                    )
+                    .awaitTransactionSuccessAsync();
+                return expect(tx).to.eventually.be.rejectedWith('NO_UNISWAP_EXCHANGE_FOR_TOKEN');
+            });
+
+            it('fails if the exchange fails', async () => {
+                const revertReason = 'FOOBAR';
+                const tx = withdrawToAsync({
+                    exchangeRevertReason: revertReason,
+                });
+                return expect(tx).to.eventually.be.rejectedWith(revertReason);
+            });
+        });
+
+        describe('token -> ETH', () => {
+            it('calls `IUniswapExchange.tokenToEthSwapInput()`, `WETH.deposit()`, then `transfer()`', async () => {
+                const { opts, logs, blockTime } = await withdrawToAsync({
+                    toTokenAddress: wethTokenAddress,
+                });
+                const exchangeAddress = await getExchangeForTokenAsync(opts.fromTokenAddress);
+                let calls: any = filterLogs<TokenToEthSwapInputArgs>(logs, ContractEvents.TokenToEthSwapInput);
+                expect(calls.length).to.eq(1);
+                expect(calls[0].args.exchange).to.eq(exchangeAddress);
+                expect(calls[0].args.tokensSold).to.bignumber.eq(opts.fromTokenBalance);
+                expect(calls[0].args.minEthBought).to.bignumber.eq(opts.amount);
+                expect(calls[0].args.deadline).to.bignumber.eq(blockTime);
+                calls = filterLogs<WethDepositArgs>(
+                    logs.slice(calls[0].logIndex as number),
+                    ContractEvents.WethDeposit,
+                );
+                expect(calls.length).to.eq(1);
+                expect(calls[0].args.amount).to.bignumber.eq(opts.exchangeFillAmount);
+                calls = filterLogs<TokenTransferArgs>(
+                    logs.slice(calls[0].logIndex as number),
+                    ContractEvents.TokenTransfer,
+                );
+                expect(calls.length).to.eq(1);
+                expect(calls[0].args.token).to.eq(opts.toTokenAddress);
+                expect(calls[0].args.from).to.eq(testContract.address);
+                expect(calls[0].args.to).to.eq(opts.toAddress);
+                expect(calls[0].args.amount).to.bignumber.eq(opts.exchangeFillAmount);
+            });
+
+            it('sets allowance for "from" token', async () => {
+                const { opts, logs } = await withdrawToAsync({
+                    toTokenAddress: wethTokenAddress,
+                });
+                const transfers = filterLogsToArguments<TokenApproveArgs>(logs, ContractEvents.TokenApprove);
+                const exchangeAddress = await getExchangeForTokenAsync(opts.fromTokenAddress);
+                expect(transfers.length).to.eq(1);
+                expect(transfers[0].spender).to.eq(exchangeAddress);
+                expect(transfers[0].allowance).to.bignumber.eq(constants.MAX_UINT256);
+            });
+
+            it('sets allowance for "from" token on subsequent calls', async () => {
+                const { opts } = await withdrawToAsync({
+                    toTokenAddress: wethTokenAddress,
+                });
+                const { logs } = await withdrawToAsync(opts);
+                const approvals = filterLogsToArguments<TokenApproveArgs>(logs, ContractEvents.TokenApprove);
+                const exchangeAddress = await getExchangeForTokenAsync(opts.fromTokenAddress);
+                expect(approvals.length).to.eq(1);
+                expect(approvals[0].spender).to.eq(exchangeAddress);
+                expect(approvals[0].allowance).to.bignumber.eq(constants.MAX_UINT256);
+            });
+
+            it('fails if "from" token does not exist', async () => {
+                const tx = testContract
+                    .bridgeTransferFrom(
+                        randomAddress(),
+                        randomAddress(),
+                        randomAddress(),
+                        getRandomInteger(1, 1e18),
+                        hexUtils.leftPad(wethTokenAddress),
+                    )
+                    .awaitTransactionSuccessAsync();
+                return expect(tx).to.eventually.be.rejectedWith('NO_UNISWAP_EXCHANGE_FOR_TOKEN');
+            });
+
+            it('fails if `WETH.deposit()` fails', async () => {
+                const revertReason = 'FOOBAR';
+                const tx = withdrawToAsync({
+                    toTokenAddress: wethTokenAddress,
+                    toTokenRevertReason: revertReason,
+                });
+                return expect(tx).to.eventually.be.rejectedWith(revertReason);
+            });
+
+            it('fails if the exchange fails', async () => {
+                const revertReason = 'FOOBAR';
+                const tx = withdrawToAsync({
+                    toTokenAddress: wethTokenAddress,
+                    exchangeRevertReason: revertReason,
+                });
+                return expect(tx).to.eventually.be.rejectedWith(revertReason);
+            });
+        });
+
+        describe('ETH -> token', () => {
+            it('calls  `WETH.withdraw()`, then `IUniswapExchange.ethToTokenTransferInput()`', async () => {
+                const { opts, logs, blockTime } = await withdrawToAsync({
+                    fromTokenAddress: wethTokenAddress,
+                });
+                const exchangeAddress = await getExchangeForTokenAsync(opts.toTokenAddress);
+                let calls: any = filterLogs<WethWithdrawArgs>(logs, ContractEvents.WethWithdraw);
+                expect(calls.length).to.eq(1);
+                expect(calls[0].args.amount).to.bignumber.eq(opts.fromTokenBalance);
+                calls = filterLogs<EthToTokenTransferInputArgs>(
+                    logs.slice(calls[0].logIndex as number),
+                    ContractEvents.EthToTokenTransferInput,
+                );
+                expect(calls.length).to.eq(1);
+                expect(calls[0].args.exchange).to.eq(exchangeAddress);
+                expect(calls[0].args.minTokensBought).to.bignumber.eq(opts.amount);
+                expect(calls[0].args.deadline).to.bignumber.eq(blockTime);
+                expect(calls[0].args.recipient).to.eq(opts.toAddress);
+            });
+
+            it('does not set any allowance', async () => {
+                const { logs } = await withdrawToAsync({
+                    fromTokenAddress: wethTokenAddress,
+                });
+                const approvals = filterLogsToArguments<TokenApproveArgs>(logs, ContractEvents.TokenApprove);
+                expect(approvals).to.be.empty('');
+            });
+
+            it('fails if "to" token does not exist', async () => {
+                const tx = testContract
+                    .bridgeTransferFrom(
+                        wethTokenAddress,
+                        randomAddress(),
+                        randomAddress(),
+                        getRandomInteger(1, 1e18),
+                        hexUtils.leftPad(randomAddress()),
+                    )
+                    .awaitTransactionSuccessAsync();
+                return expect(tx).to.eventually.be.rejectedWith('NO_UNISWAP_EXCHANGE_FOR_TOKEN');
+            });
+
+            it('fails if the `WETH.withdraw()` fails', async () => {
+                const revertReason = 'FOOBAR';
+                const tx = withdrawToAsync({
+                    fromTokenAddress: wethTokenAddress,
+                    fromTokenRevertReason: revertReason,
+                });
+                return expect(tx).to.eventually.be.rejectedWith(revertReason);
+            });
+
+            it('fails if the exchange fails', async () => {
+                const revertReason = 'FOOBAR';
+                const tx = withdrawToAsync({
+                    fromTokenAddress: wethTokenAddress,
+                    exchangeRevertReason: revertReason,
+                });
+                return expect(tx).to.eventually.be.rejectedWith(revertReason);
+            });
+        });
+    });
+});

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

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

contracts/asset-proxy/test/wrappers.ts

@@ -0,0 +1,38 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+export * from '../test/generated-wrappers/chai_bridge';
+export * from '../test/generated-wrappers/dydx_bridge';
+export * from '../test/generated-wrappers/erc1155_proxy';
+export * from '../test/generated-wrappers/erc20_bridge_proxy';
+export * from '../test/generated-wrappers/erc20_proxy';
+export * from '../test/generated-wrappers/erc721_proxy';
+export * from '../test/generated-wrappers/eth2_dai_bridge';
+export * from '../test/generated-wrappers/i_asset_data';
+export * from '../test/generated-wrappers/i_asset_proxy';
+export * from '../test/generated-wrappers/i_asset_proxy_dispatcher';
+export * from '../test/generated-wrappers/i_authorizable';
+export * from '../test/generated-wrappers/i_chai';
+export * from '../test/generated-wrappers/i_dydx';
+export * from '../test/generated-wrappers/i_dydx_bridge';
+export * from '../test/generated-wrappers/i_erc20_bridge';
+export * from '../test/generated-wrappers/i_eth2_dai';
+export * from '../test/generated-wrappers/i_kyber_network_proxy';
+export * from '../test/generated-wrappers/i_uniswap_exchange';
+export * from '../test/generated-wrappers/i_uniswap_exchange_factory';
+export * from '../test/generated-wrappers/kyber_bridge';
+export * from '../test/generated-wrappers/mixin_asset_proxy_dispatcher';
+export * from '../test/generated-wrappers/mixin_authorizable';
+export * from '../test/generated-wrappers/multi_asset_proxy';
+export * from '../test/generated-wrappers/ownable';
+export * from '../test/generated-wrappers/static_call_proxy';
+export * from '../test/generated-wrappers/test_chai_bridge';
+export * from '../test/generated-wrappers/test_dydx_bridge';
+export * from '../test/generated-wrappers/test_erc20_bridge';
+export * from '../test/generated-wrappers/test_eth2_dai_bridge';
+export * from '../test/generated-wrappers/test_kyber_bridge';
+export * from '../test/generated-wrappers/test_static_call_target';
+export * from '../test/generated-wrappers/test_uniswap_bridge';
+export * from '../test/generated-wrappers/uniswap_bridge';

contracts/asset-proxy/truffle-config.js

@@ -84,7 +84,7 @@ module.exports = {
         solc: {
             version: '0.5.9',
             settings: {
-                evmVersion: 'constantinople',
+                evmVersion: 'istanbul',
                 optimizer: {
                     enabled: true,
                     runs: 1000000,

contracts/asset-proxy/tsconfig.json

@@ -3,6 +3,8 @@
     "compilerOptions": { "outDir": "lib", "rootDir": ".", "resolveJsonModule": true },
     "include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*"],
     "files": [
+        "generated-artifacts/ChaiBridge.json",
+        "generated-artifacts/DydxBridge.json",
         "generated-artifacts/ERC1155Proxy.json",
         "generated-artifacts/ERC20BridgeProxy.json",
         "generated-artifacts/ERC20Proxy.json",
@@ -12,17 +14,61 @@
         "generated-artifacts/IAssetProxy.json",
         "generated-artifacts/IAssetProxyDispatcher.json",
         "generated-artifacts/IAuthorizable.json",
+        "generated-artifacts/IChai.json",
+        "generated-artifacts/IDydx.json",
+        "generated-artifacts/IDydxBridge.json",
         "generated-artifacts/IERC20Bridge.json",
         "generated-artifacts/IEth2Dai.json",
-        "generated-artifacts/IWallet.json",
+        "generated-artifacts/IKyberNetworkProxy.json",
+        "generated-artifacts/IUniswapExchange.json",
+        "generated-artifacts/IUniswapExchangeFactory.json",
+        "generated-artifacts/KyberBridge.json",
         "generated-artifacts/MixinAssetProxyDispatcher.json",
         "generated-artifacts/MixinAuthorizable.json",
         "generated-artifacts/MultiAssetProxy.json",
         "generated-artifacts/Ownable.json",
         "generated-artifacts/StaticCallProxy.json",
+        "generated-artifacts/TestChaiBridge.json",
+        "generated-artifacts/TestDydxBridge.json",
         "generated-artifacts/TestERC20Bridge.json",
         "generated-artifacts/TestEth2DaiBridge.json",
-        "generated-artifacts/TestStaticCallTarget.json"
+        "generated-artifacts/TestKyberBridge.json",
+        "generated-artifacts/TestStaticCallTarget.json",
+        "generated-artifacts/TestUniswapBridge.json",
+        "generated-artifacts/UniswapBridge.json",
+        "test/generated-artifacts/ChaiBridge.json",
+        "test/generated-artifacts/DydxBridge.json",
+        "test/generated-artifacts/ERC1155Proxy.json",
+        "test/generated-artifacts/ERC20BridgeProxy.json",
+        "test/generated-artifacts/ERC20Proxy.json",
+        "test/generated-artifacts/ERC721Proxy.json",
+        "test/generated-artifacts/Eth2DaiBridge.json",
+        "test/generated-artifacts/IAssetData.json",
+        "test/generated-artifacts/IAssetProxy.json",
+        "test/generated-artifacts/IAssetProxyDispatcher.json",
+        "test/generated-artifacts/IAuthorizable.json",
+        "test/generated-artifacts/IChai.json",
+        "test/generated-artifacts/IDydx.json",
+        "test/generated-artifacts/IDydxBridge.json",
+        "test/generated-artifacts/IERC20Bridge.json",
+        "test/generated-artifacts/IEth2Dai.json",
+        "test/generated-artifacts/IKyberNetworkProxy.json",
+        "test/generated-artifacts/IUniswapExchange.json",
+        "test/generated-artifacts/IUniswapExchangeFactory.json",
+        "test/generated-artifacts/KyberBridge.json",
+        "test/generated-artifacts/MixinAssetProxyDispatcher.json",
+        "test/generated-artifacts/MixinAuthorizable.json",
+        "test/generated-artifacts/MultiAssetProxy.json",
+        "test/generated-artifacts/Ownable.json",
+        "test/generated-artifacts/StaticCallProxy.json",
+        "test/generated-artifacts/TestChaiBridge.json",
+        "test/generated-artifacts/TestDydxBridge.json",
+        "test/generated-artifacts/TestERC20Bridge.json",
+        "test/generated-artifacts/TestEth2DaiBridge.json",
+        "test/generated-artifacts/TestKyberBridge.json",
+        "test/generated-artifacts/TestStaticCallTarget.json",
+        "test/generated-artifacts/TestUniswapBridge.json",
+        "test/generated-artifacts/UniswapBridge.json"
     ],
     "exclude": ["./deploy/solc/solc_bin"]
 }

contracts/coordinator/.npmignore

@@ -0,0 +1,10 @@
+# Blacklist all files
+.*
+*
+# Whitelist lib
+!lib/**/*
+# Whitelist Solidity contracts
+!contracts/src/**/*
+# Blacklist tests in lib
+/lib/test/*
+# Package specific ignore

contracts/coordinator/CHANGELOG.json

@@ -1,4 +1,143 @@
 [
+    {
+        "timestamp": 1579682890,
+        "version": "3.0.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1578272714,
+        "version": "3.0.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1576540892,
+        "version": "3.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1575931811,
+        "version": "3.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "3.0.0",
+        "changes": [
+            {
+                "note": "Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils",
+                "pr": 2330
+            },
+            {
+                "note": "Introduced new export CoordinatorRevertErrors",
+                "pr": 2321
+            },
+            {
+                "note": "Added dependency on @0x/contracts-utils",
+                "pr": 2321
+            },
+            {
+                "note": "Add chainId to domain separator",
+                "pr": 1742
+            },
+            {
+                "note": "Inherit Exchange domain constants from `exchange-libs` to reduce code duplication",
+                "pr": 1742
+            },
+            {
+                "note": "Update domain separator",
+                "pr": 1742
+            },
+            {
+                "note": "Refactor contract to use new ITransactions interface",
+                "pr": 1753
+            },
+            {
+                "note": "Add verifyingContractIfExists arg to LibEIP712CoordinatorDomain constructor",
+                "pr": 1753
+            },
+            {
+                "note": "Remove LibZeroExTransaction contract",
+                "pr": 1753
+            },
+            {
+                "note": "Update tests for arbitrary fee tokens (ZEIP-28).",
+                "pr": 1819
+            },
+            {
+                "note": "Update for new `marketXOrders` consolidation.",
+                "pr": 2042
+            },
+            {
+                "note": "Use built in selectors instead of hard coded constants",
+                "pr": 2055
+            },
+            {
+                "note": "Compile and export all contracts, artifacts, and wrappers by default",
+                "pr": 2055
+            }
+        ],
+        "timestamp": 1575296764
+    },
+    {
+        "version": "2.1.0-beta.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ],
+        "timestamp": 1575290197
+    },
+    {
+        "version": "2.1.0-beta.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ],
+        "timestamp": 1574238768
+    },
+    {
+        "version": "2.1.0-beta.2",
+        "changes": [
+            {
+                "note": "Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils",
+                "pr": 2330
+            },
+            {
+                "note": "Introduced new export CoordinatorRevertErrors",
+                "pr": 2321
+            },
+            {
+                "note": "Added dependency on @0x/contracts-utils",
+                "pr": 2321
+            }
+        ],
+        "timestamp": 1574030254
+    },
+    {
+        "version": "2.1.0-beta.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ],
+        "timestamp": 1573159180
+    },
     {
         "version": "2.1.0-beta.0",
         "changes": [

contracts/coordinator/CHANGELOG.md

@@ -5,6 +5,56 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v3.0.4 - _January 22, 2020_
+
+    * Dependencies updated
+
+## v3.0.3 - _January 6, 2020_
+
+    * Dependencies updated
+
+## v3.0.2 - _December 17, 2019_
+
+    * Dependencies updated
+
+## v3.0.1 - _December 9, 2019_
+
+    * Dependencies updated
+
+## v3.0.0 - _December 2, 2019_
+
+    * Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils (#2330)
+    * Introduced new export CoordinatorRevertErrors (#2321)
+    * Added dependency on @0x/contracts-utils (#2321)
+    * Add chainId to domain separator (#1742)
+    * Inherit Exchange domain constants from `exchange-libs` to reduce code duplication (#1742)
+    * Update domain separator (#1742)
+    * Refactor contract to use new ITransactions interface (#1753)
+    * Add verifyingContractIfExists arg to LibEIP712CoordinatorDomain constructor (#1753)
+    * Remove LibZeroExTransaction contract (#1753)
+    * Update tests for arbitrary fee tokens (ZEIP-28). (#1819)
+    * Update for new `marketXOrders` consolidation. (#2042)
+    * Use built in selectors instead of hard coded constants (#2055)
+    * Compile and export all contracts, artifacts, and wrappers by default (#2055)
+
+## v2.1.0-beta.4 - _December 2, 2019_
+
+    * Dependencies updated
+
+## v2.1.0-beta.3 - _November 20, 2019_
+
+    * Dependencies updated
+
+## v2.1.0-beta.2 - _November 17, 2019_
+
+    * Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils (#2330)
+    * Introduced new export CoordinatorRevertErrors (#2321)
+    * Added dependency on @0x/contracts-utils (#2321)
+
+## v2.1.0-beta.1 - _November 7, 2019_
+
+    * Dependencies updated
+
 ## v2.1.0-beta.0 - _October 3, 2019_
 
     * Add chainId to domain separator (#1742)

contracts/coordinator/compiler.json

@@ -1,9 +1,9 @@
 {
-    "artifactsDir": "./generated-artifacts",
+    "artifactsDir": "./test/generated-artifacts",
     "contractsDir": "./contracts",
     "useDockerisedSolc": false,
     "compilerSettings": {
-        "evmVersion": "constantinople",
+        "evmVersion": "istanbul",
         "optimizer": {
             "enabled": true,
             "runs": 1000000,

contracts/coordinator/contracts/src/MixinCoordinatorApprovalVerifier.sol

@@ -19,12 +19,15 @@
 pragma solidity ^0.5.9;
 pragma experimental ABIEncoderV2;
 
+import "@0x/contracts-exchange-libs/contracts/src/LibEIP712ExchangeDomain.sol";
 import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
 import "@0x/contracts-exchange-libs/contracts/src/LibZeroExTransaction.sol";
-import "@0x/contracts-utils/contracts/src/LibBytes.sol";
 import "@0x/contracts-utils/contracts/src/LibAddressArray.sol";
+import "@0x/contracts-utils/contracts/src/LibBytes.sol";
+import "@0x/contracts-utils/contracts/src/LibRichErrors.sol";
 import "@0x/contracts-exchange/contracts/src/interfaces/IExchange.sol";
 import "./libs/LibCoordinatorApproval.sol";
+import "./libs/LibCoordinatorRichErrors.sol";
 import "./interfaces/ICoordinatorSignatureValidator.sol";
 import "./interfaces/ICoordinatorApprovalVerifier.sol";
 
@@ -32,7 +35,7 @@ import "./interfaces/ICoordinatorApprovalVerifier.sol";
 // solhint-disable avoid-tx-origin
 contract MixinCoordinatorApprovalVerifier is
     LibCoordinatorApproval,
-    LibZeroExTransaction,
+    LibEIP712ExchangeDomain,
     ICoordinatorSignatureValidator,
     ICoordinatorApprovalVerifier
 {
@@ -44,13 +47,12 @@ contract MixinCoordinatorApprovalVerifier is
     /// @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.
+    /// @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
@@ -67,7 +69,6 @@ contract MixinCoordinatorApprovalVerifier is
                 orders,
                 txOrigin,
                 transactionSignature,
-                approvalExpirationTimeSeconds,
                 approvalSignatures
             );
         }
@@ -75,7 +76,7 @@ contract MixinCoordinatorApprovalVerifier is
 
     /// @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.
+    /// @return orders The orders from the Exchange calldata.
     function decodeOrdersFromFillData(bytes memory data)
         public
         pure
@@ -84,7 +85,6 @@ contract MixinCoordinatorApprovalVerifier is
         bytes4 selector = data.readBytes4(0);
         if (
             selector == IExchange(address(0)).fillOrder.selector ||
-            selector == IExchange(address(0)).fillOrderNoThrow.selector ||
             selector == IExchange(address(0)).fillOrKillOrder.selector
         ) {
             // Decode single order
@@ -98,8 +98,10 @@ contract MixinCoordinatorApprovalVerifier is
             selector == IExchange(address(0)).batchFillOrders.selector ||
             selector == IExchange(address(0)).batchFillOrdersNoThrow.selector ||
             selector == IExchange(address(0)).batchFillOrKillOrders.selector ||
-            selector == IExchange(address(0)).marketBuyOrders.selector ||
-            selector == IExchange(address(0)).marketSellOrders.selector
+            selector == IExchange(address(0)).marketBuyOrdersNoThrow.selector ||
+            selector == IExchange(address(0)).marketBuyOrdersFillOrKill.selector ||
+            selector == IExchange(address(0)).marketSellOrdersNoThrow.selector ||
+            selector == IExchange(address(0)).marketSellOrdersFillOrKill.selector
         ) {
             // Decode all orders
             // solhint-disable indent
@@ -107,7 +109,10 @@ contract MixinCoordinatorApprovalVerifier is
                 data.slice(4, data.length),
                 (LibOrder.Order[])
             );
-        } else if (selector == IExchange(address(0)).matchOrders.selector) {
+        } else if (
+            selector == IExchange(address(0)).matchOrders.selector ||
+            selector == IExchange(address(0)).matchOrdersWithMaximalFill.selector
+        ) {
             // Decode left and right orders
             (LibOrder.Order memory leftOrder, LibOrder.Order memory rightOrder) = abi.decode(
                 data.slice(4, data.length),
@@ -127,27 +132,24 @@ contract MixinCoordinatorApprovalVerifier is
     /// @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"
-        );
+        if (tx.origin != txOrigin) {
+            LibRichErrors.rrevert(LibCoordinatorRichErrors.InvalidOriginError(txOrigin));
+        }
 
         // Hash 0x transaction
-        bytes32 transactionHash = getTransactionHash(transaction);
+        bytes32 transactionHash = LibZeroExTransaction.getTypedDataHash(transaction, EIP712_EXCHANGE_DOMAIN_HASH);
 
         // Create empty list of approval signers
         address[] memory approvalSignerAddresses = new address[](0);
@@ -155,21 +157,12 @@ contract MixinCoordinatorApprovalVerifier is
         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
+                transactionSignature: transactionSignature
             });
 
-            // 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]);
@@ -191,10 +184,12 @@ contract MixinCoordinatorApprovalVerifier is
             // Ensure feeRecipient of order has approved this 0x transaction
             address approverAddress = orders[i].feeRecipientAddress;
             bool isOrderApproved = approvalSignerAddresses.contains(approverAddress);
-            require(
-                isOrderApproved,
-                "INVALID_APPROVAL_SIGNATURE"
-            );
+            if (!isOrderApproved) {
+                LibRichErrors.rrevert(LibCoordinatorRichErrors.InvalidApprovalSignatureError(
+                    transactionHash,
+                    approverAddress
+                ));
+            }
         }
     }
 }

contracts/coordinator/contracts/src/MixinCoordinatorCore.sol

@@ -20,41 +20,53 @@ pragma solidity ^0.5.9;
 pragma experimental ABIEncoderV2;
 
 import "@0x/contracts-exchange-libs/contracts/src/LibZeroExTransaction.sol";
+import "@0x/contracts-utils/contracts/src/Refundable.sol";
 import "./libs/LibConstants.sol";
 import "./interfaces/ICoordinatorCore.sol";
 import "./interfaces/ICoordinatorApprovalVerifier.sol";
 
 
+// solhint-disable no-empty-blocks
 contract MixinCoordinatorCore is
+    Refundable,
     LibConstants,
     ICoordinatorApprovalVerifier,
     ICoordinatorCore
 {
-    /// @dev Executes a 0x transaction that has been signed by the feeRecipients that correspond to each order in the transaction's Exchange calldata.
+
+    /// @dev A payable fallback function that makes this contract "payable". This is necessary to allow
+    ///      this contract to gracefully handle refunds from the Exchange.
+    function ()
+        external
+        payable
+    {}
+
+    /// @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.
+    /// @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
+        payable
+        refundFinalBalance
     {
         // Validate that the 0x transaction has been approves by each feeRecipient
         assertValidCoordinatorApprovals(
             transaction,
             txOrigin,
             transactionSignature,
-            approvalExpirationTimeSeconds,
             approvalSignatures
         );
 
         // Execute the transaction
-        EXCHANGE.executeTransaction(transaction, transactionSignature);
+        EXCHANGE.executeTransaction.value(msg.value)(transaction, transactionSignature);
     }
 }

contracts/coordinator/contracts/src/MixinSignatureValidator.sol

@@ -19,7 +19,9 @@
 pragma solidity ^0.5.9;
 
 import "@0x/contracts-utils/contracts/src/LibBytes.sol";
+import "@0x/contracts-utils/contracts/src/LibRichErrors.sol";
 import "./interfaces/ICoordinatorSignatureValidator.sol";
+import "./libs/LibCoordinatorRichErrors.sol";
 
 
 contract MixinSignatureValidator is
@@ -30,24 +32,32 @@ contract MixinSignatureValidator is
     /// @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.
+    /// @return signerAddress Address of the signer.
     function getSignerAddress(bytes32 hash, bytes memory signature)
         public
         pure
         returns (address signerAddress)
     {
-        require(
-            signature.length > 0,
-            "LENGTH_GREATER_THAN_0_REQUIRED"
-        );
+        uint256 signatureLength = signature.length;
+        if (signatureLength == 0) {
+            LibRichErrors.rrevert(LibCoordinatorRichErrors.SignatureError(
+                LibCoordinatorRichErrors.SignatureErrorCodes.INVALID_LENGTH,
+                hash,
+                signature
+            ));
+        }
 
         // Pop last byte off of signature byte array.
-        uint8 signatureTypeRaw = uint8(signature.popLastByte());
+        uint8 signatureTypeRaw = uint8(signature[signature.length - 1]);
 
         // Ensure signature is supported
-        require(
-            signatureTypeRaw < uint8(SignatureType.NSignatureTypes),
-            "SIGNATURE_UNSUPPORTED"
-        );
+        if (signatureTypeRaw >= uint8(SignatureType.NSignatureTypes)) {
+            LibRichErrors.rrevert(LibCoordinatorRichErrors.SignatureError(
+                LibCoordinatorRichErrors.SignatureErrorCodes.UNSUPPORTED,
+                hash,
+                signature
+            ));
+        }
 
         SignatureType signatureType = SignatureType(signatureTypeRaw);
 
@@ -57,25 +67,32 @@ contract MixinSignatureValidator is
         // 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");
+            LibRichErrors.rrevert(LibCoordinatorRichErrors.SignatureError(
+                LibCoordinatorRichErrors.SignatureErrorCodes.ILLEGAL,
+                hash,
+                signature
+            ));
 
         // 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");
+            LibRichErrors.rrevert(LibCoordinatorRichErrors.SignatureError(
+                LibCoordinatorRichErrors.SignatureErrorCodes.INVALID,
+                hash,
+                signature
+            ));
 
         // Signature using EIP712
         } else if (signatureType == SignatureType.EIP712) {
-            require(
-                signature.length == 65,
-                "LENGTH_65_REQUIRED"
-            );
+            if (signatureLength != 66) {
+                LibRichErrors.rrevert(LibCoordinatorRichErrors.SignatureError(
+                    LibCoordinatorRichErrors.SignatureErrorCodes.INVALID_LENGTH,
+                    hash,
+                    signature
+                ));
+            }
             uint8 v = uint8(signature[0]);
             bytes32 r = signature.readBytes32(1);
             bytes32 s = signature.readBytes32(33);
@@ -89,10 +106,13 @@ contract MixinSignatureValidator is
 
         // Signed using web3.eth_sign
         } else if (signatureType == SignatureType.EthSign) {
-            require(
-                signature.length == 65,
-                "LENGTH_65_REQUIRED"
-            );
+            if (signatureLength != 66) {
+                LibRichErrors.rrevert(LibCoordinatorRichErrors.SignatureError(
+                    LibCoordinatorRichErrors.SignatureErrorCodes.INVALID_LENGTH,
+                    hash,
+                    signature
+                ));
+            }
             uint8 v = uint8(signature[0]);
             bytes32 r = signature.readBytes32(1);
             bytes32 s = signature.readBytes32(33);
@@ -113,6 +133,10 @@ contract MixinSignatureValidator is
         // that we currently support. In this case returning false
         // may lead the caller to incorrectly believe that the
         // signature was invalid.)
-        revert("SIGNATURE_UNSUPPORTED");
+        LibRichErrors.rrevert(LibCoordinatorRichErrors.SignatureError(
+            LibCoordinatorRichErrors.SignatureErrorCodes.UNSUPPORTED,
+            hash,
+            signature
+        ));
     }
 }

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

@@ -30,13 +30,12 @@ contract ICoordinatorApprovalVerifier {
     /// @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.
+    /// @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
@@ -44,7 +43,7 @@ contract ICoordinatorApprovalVerifier {
 
     /// @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.
+    /// @return orders The orders from the Exchange calldata.
     function decodeOrdersFromFillData(bytes memory data)
         public
         pure

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

@@ -24,18 +24,19 @@ import "@0x/contracts-exchange-libs/contracts/src/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.
+    /// @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.
+    /// @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;
+        public
+        payable;
 }

contracts/coordinator/contracts/src/interfaces/ICoordinatorSignatureValidator.sol

@@ -30,14 +30,14 @@ contract ICoordinatorSignatureValidator {
         Wallet,                 // 0x04
         Validator,              // 0x05
         PreSigned,              // 0x06
-        OrderValidator,         // 0x07
-        WalletOrderValidator,   // 0x08
-        NSignatureTypes         // 0x09, number of signature types. Always leave at end.
+        EIP1271Wallet,          // 0x07
+        NSignatureTypes         // 0x08, number of signature types. Always leave at end.
     }
 
     /// @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.
+    /// @return signerAddress Address of the signer. 
     function getSignerAddress(bytes32 hash, bytes memory signature)
         public
         pure

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

@@ -30,22 +30,24 @@ contract LibCoordinatorApproval is
     //     "CoordinatorApproval(",
     //     "address txOrigin,",
     //     "bytes32 transactionHash,",
-    //     "bytes transactionSignature,",
-    //     "uint256 approvalExpirationTimeSeconds",
+    //     "bytes transactionSignature",
     //     ")"
     // ));
-    bytes32 constant public EIP712_COORDINATOR_APPROVAL_SCHEMA_HASH = 0x2fbcdbaa76bc7589916958ae919dfbef04d23f6bbf26de6ff317b32c6cc01e05;
+    bytes32 constant public EIP712_COORDINATOR_APPROVAL_SCHEMA_HASH =
+        0xa6511c04ca44625d50986f8c36bedc09366207a17b96e347094053a9f8507168;
 
     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.
+    /// @dev Calculates the EIP712 hash of the Coordinator approval mesasage using the domain
+    ///      separator of this contract.
+    /// @param approval Coordinator approval message containing the transaction hash, and transaction
+    ///        signature.
+    /// @return approvalHash EIP712 hash of the Coordinator approval message with the domain
+    ///         separator of this contract.
     function getCoordinatorApprovalHash(CoordinatorApproval memory approval)
         public
         view
@@ -55,9 +57,10 @@ contract LibCoordinatorApproval is
         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.
+    /// @dev Calculates the EIP712 hash of the Coordinator approval mesasage with no domain separator.
+    /// @param approval Coordinator approval message containing the transaction hash, and transaction
+    //         signature.
+    /// @return result EIP712 hash of the Coordinator approval message with no domain separator.
     function _hashCoordinatorApproval(CoordinatorApproval memory approval)
         internal
         pure
@@ -67,7 +70,6 @@ contract LibCoordinatorApproval is
         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(
@@ -75,7 +77,6 @@ contract LibCoordinatorApproval is
         //     approval.txOrigin,
         //     approval.transactionHash,
         //     keccak256(approval.transactionSignature)
-        //     approval.approvalExpirationTimeSeconds,
         // ));
 
         assembly {
@@ -89,9 +90,8 @@ contract LibCoordinatorApproval is
             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)
+            result := keccak256(memPtr, 128)
         }
         return result;
     }

contracts/coordinator/contracts/src/libs/LibCoordinatorRichErrors.sol

@@ -0,0 +1,87 @@
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.9;
+
+
+library LibCoordinatorRichErrors {
+    enum SignatureErrorCodes {
+        INVALID_LENGTH,
+        UNSUPPORTED,
+        ILLEGAL,
+        INVALID
+    }
+
+    // bytes4(keccak256("SignatureError(uint8,bytes32,bytes)"))
+    bytes4 internal constant SIGNATURE_ERROR_SELECTOR =
+        0x779c5223;
+
+    // bytes4(keccak256("InvalidOriginError(address)"))
+    bytes4 internal constant INVALID_ORIGIN_ERROR_SELECTOR =
+        0xa458d7ff;
+
+    // bytes4(keccak256("InvalidApprovalSignatureError(bytes32,address)"))
+    bytes4 internal constant INVALID_APPROVAL_SIGNATURE_ERROR_SELECTOR =
+        0xd789b640;
+
+    // solhint-disable func-name-mixedcase
+    function SignatureError(
+        SignatureErrorCodes errorCode,
+        bytes32 hash,
+        bytes memory signature
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            SIGNATURE_ERROR_SELECTOR,
+            errorCode,
+            hash,
+            signature
+        );
+    }
+
+    function InvalidOriginError(
+        address expectedOrigin
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            INVALID_ORIGIN_ERROR_SELECTOR,
+            expectedOrigin
+        );
+    }
+
+    function InvalidApprovalSignatureError(
+        bytes32 transactionHash,
+        address approverAddress
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            INVALID_APPROVAL_SIGNATURE_ERROR_SELECTOR,
+            transactionHash,
+            approverAddress
+        );
+    }
+}

contracts/coordinator/contracts/src/libs/LibEIP712CoordinatorDomain.sol

@@ -21,15 +21,13 @@ pragma solidity ^0.5.9;
 import "@0x/contracts-utils/contracts/src/LibEIP712.sol";
 
 
-contract LibEIP712CoordinatorDomain is
-    LibEIP712
-{
+contract LibEIP712CoordinatorDomain {
 
     // EIP712 Domain Name value for the Coordinator
     string constant public EIP712_COORDINATOR_DOMAIN_NAME = "0x Protocol Coordinator";
 
     // EIP712 Domain Version value for the Coordinator
-    string constant public EIP712_COORDINATOR_DOMAIN_VERSION = "2.0.0";
+    string constant public EIP712_COORDINATOR_DOMAIN_VERSION = "3.0.0";
 
     // Hash of the EIP712 Domain Separator data for the Coordinator
     // solhint-disable-next-line var-name-mixedcase
@@ -43,7 +41,9 @@ contract LibEIP712CoordinatorDomain is
     )
         public
     {
-        address verifyingContractAddress = verifyingContractAddressIfExists == address(0) ? address(this) : verifyingContractAddressIfExists;
+        address verifyingContractAddress = verifyingContractAddressIfExists == address(0)
+            ? address(this)
+            : verifyingContractAddressIfExists;
         EIP712_COORDINATOR_DOMAIN_HASH = LibEIP712.hashEIP712Domain(
             EIP712_COORDINATOR_DOMAIN_NAME,
             EIP712_COORDINATOR_DOMAIN_VERSION,
@@ -55,7 +55,7 @@ contract LibEIP712CoordinatorDomain is
     /// @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.
+    /// @return result EIP712 hash applied to this EIP712 Domain.
     function _hashEIP712CoordinatorMessage(bytes32 hashStruct)
         internal
         view

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

@@ -29,7 +29,7 @@ contract MixinCoordinatorRegistryCore is
     mapping (address => string) internal coordinatorEndpoints;
 
     /// @dev Called by a Coordinator operator to set the endpoint of their Coordinator.
-    /// @param coordinatorEndpoint endpoint of the Coordinator.
+    /// @param coordinatorEndpoint Endpoint of the Coordinator as a string.
     function setCoordinatorEndpoint(string calldata coordinatorEndpoint) external {
         address coordinatorOperator = msg.sender;
         coordinatorEndpoints[coordinatorOperator] = coordinatorEndpoint;
@@ -37,7 +37,8 @@ contract MixinCoordinatorRegistryCore is
     }
 
     /// @dev Gets the endpoint for a Coordinator.
-    /// @param coordinatorOperator operator of the Coordinator endpoint.
+    /// @param coordinatorOperator Operator of the Coordinator endpoint.
+    /// @return coordinatorEndpoint Endpoint of the Coordinator as a string.
     function getCoordinatorEndpoint(address coordinatorOperator)
         external
         view

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

@@ -29,11 +29,12 @@ contract ICoordinatorRegistryCore
     );
 
     /// @dev Called by a Coordinator operator to set the endpoint of their Coordinator.
-    /// @param coordinatorEndpoint endpoint of the Coordinator.
+    /// @param coordinatorEndpoint Endpoint of the Coordinator as a string.
     function setCoordinatorEndpoint(string calldata coordinatorEndpoint) external;
 
     /// @dev Gets the endpoint for a Coordinator.
-    /// @param coordinatorOperator operator of the Coordinator endpoint.
+    /// @param coordinatorOperator Operator of the Coordinator endpoint.
+    /// @return coordinatorEndpoint Endpoint of the Coordinator as a string.
     function getCoordinatorEndpoint(address coordinatorOperator)
         external
         view

contracts/coordinator/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-coordinator",
-    "version": "2.1.0-beta.0",
+    "version": "3.0.4",
     "engines": {
         "node": ">=6.12"
     },
@@ -12,7 +12,7 @@
     "scripts": {
         "build": "yarn pre_build && tsc -b",
         "build:ci": "yarn build",
-        "pre_build": "run-s compile contracts:gen generate_contract_wrappers",
+        "pre_build": "run-s compile contracts:gen generate_contract_wrappers contracts:copy",
         "test": "yarn run_mocha",
         "rebuild_and_test": "run-s build test",
         "test:coverage": "SOLIDITY_COVERAGE=true run-s build run_mocha coverage:report:text coverage:report:lcov",
@@ -21,21 +21,25 @@
         "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} --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",
+        "clean": "shx rm -rf lib test/generated-artifacts test/generated-wrappers generated-artifacts generated-wrappers",
+        "generate_contract_wrappers": "abi-gen --debug --abis  ${npm_package_config_abis} --output test/generated-wrappers --backend ethers",
+        "lint": "tslint --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./test/generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude ./test/generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
+        "fix": "tslint --fix --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./test/generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude ./test/generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
         "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",
+        "contracts:gen": "contracts-gen generate",
+        "contracts:copy": "contracts-gen copy",
         "lint-contracts": "solhint -c ../.solhint.json contracts/**/**/**/**/*.sol",
-        "compile:truffle": "truffle compile"
+        "compile:truffle": "truffle compile",
+        "docs:md": "ts-doc-gen --sourceDir='$PROJECT_FILES' --output=$MD_FILE_DIR --fileExtension=mdx --tsconfig=./typedoc-tsconfig.json",
+        "docs:json": "typedoc --excludePrivate --excludeExternals --excludeProtected --ignoreCompilerErrors --target ES5 --tsconfig typedoc-tsconfig.json --json $JSON_FILE_PATH $PROJECT_FILES"
     },
     "config": {
-        "abis": "./generated-artifacts/@(Coordinator|CoordinatorRegistry).json",
+        "publicInterfaceContracts": "Coordinator,CoordinatorRegistry,LibCoordinatorApproval,LibCoordinatorRichErrors,LibEIP712CoordinatorDomain,LibConstants",
+        "abis": "./test/generated-artifacts/@(Coordinator|CoordinatorRegistry|ICoordinatorApprovalVerifier|ICoordinatorCore|ICoordinatorRegistryCore|ICoordinatorSignatureValidator|LibConstants|LibCoordinatorApproval|LibCoordinatorRichErrors|LibEIP712CoordinatorDomain|MixinCoordinatorApprovalVerifier|MixinCoordinatorCore|MixinCoordinatorRegistryCore|MixinSignatureValidator).json",
         "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually."
     },
     "repository": {
@@ -48,12 +52,19 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/extensions/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^4.3.0-beta.0",
-        "@0x/contracts-gen": "^1.1.0-beta.0",
-        "@0x/contracts-test-utils": "^3.2.0-beta.0",
-        "@0x/dev-utils": "^2.4.0-beta.0",
-        "@0x/sol-compiler": "^3.2.0-beta.0",
-        "@0x/tslint-config": "^3.0.1",
+        "@0x/abi-gen": "^5.1.0",
+        "@0x/contracts-asset-proxy": "^3.1.1",
+        "@0x/contracts-dev-utils": "^1.0.4",
+        "@0x/contracts-erc20": "^3.0.4",
+        "@0x/contracts-exchange": "^3.1.0",
+        "@0x/contracts-gen": "^2.0.4",
+        "@0x/contracts-test-utils": "^5.1.1",
+        "@0x/dev-utils": "^3.1.1",
+        "@0x/order-utils": "^10.1.1",
+        "@0x/sol-compiler": "^4.0.4",
+        "@0x/ts-doc-gen": "^0.0.22",
+        "@0x/tslint-config": "^4.0.0",
+        "@0x/web3-wrapper": "^7.0.4",
         "@types/lodash": "4.14.104",
         "@types/mocha": "^5.2.7",
         "@types/node": "*",
@@ -61,6 +72,7 @@
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
+        "lodash": "^4.17.11",
         "make-promises-safe": "^1.1.0",
         "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
@@ -68,23 +80,20 @@
         "solhint": "^1.4.1",
         "truffle": "^5.0.32",
         "tslint": "5.11.0",
+        "typedoc": "^0.15.0",
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.5.0-beta.0",
-        "@0x/contracts-asset-proxy": "^2.3.0-beta.0",
-        "@0x/contracts-erc20": "^2.3.0-beta.0",
-        "@0x/contracts-exchange": "^2.2.0-beta.0",
-        "@0x/contracts-exchange-libs": "^3.1.0-beta.0",
-        "@0x/contracts-utils": "^3.3.0-beta.0",
-        "@0x/order-utils": "^8.5.0-beta.0",
-        "@0x/types": "^2.5.0-beta.0",
-        "@0x/typescript-typings": "^4.4.0-beta.0",
-        "@0x/utils": "^4.6.0-beta.0",
-        "@0x/web3-wrapper": "^6.1.0-beta.0",
-        "ethereum-types": "^2.2.0-beta.0",
-        "ethereumjs-util": "^5.1.1",
-        "lodash": "^4.17.11"
+        "@0x/assert": "^3.0.4",
+        "@0x/base-contract": "^6.1.0",
+        "@0x/contract-addresses": "^4.3.0",
+        "@0x/contracts-utils": "^4.1.0",
+        "@0x/json-schemas": "^5.0.4",
+        "@0x/types": "^3.1.1",
+        "@0x/typescript-typings": "^5.0.1",
+        "@0x/utils": "^5.2.0",
+        "ethereum-types": "^3.0.0",
+        "http-status-codes": "^1.3.2"
     },
     "publishConfig": {
         "access": "public"

contracts/coordinator/src/approval_factory.ts

@@ -1,9 +1,9 @@
 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 { hexUtils } from '@0x/utils';
 
-import { hashUtils, SignedCoordinatorApproval } from './index';
+import { hashUtils } from './hash_utils';
+import { SignedCoordinatorApproval } from './types';
 
 export class ApprovalFactory {
     private readonly _privateKey: Buffer;
@@ -14,24 +14,21 @@ export class ApprovalFactory {
         this._verifyingContractAddress = verifyingContract;
     }
 
-    public newSignedApproval(
+    public async newSignedApprovalAsync(
         transaction: SignedZeroExTransaction,
         txOrigin: string,
-        approvalExpirationTimeSeconds: BigNumber,
         signatureType: SignatureType = SignatureType.EthSign,
-    ): SignedCoordinatorApproval {
-        const approvalHashBuff = hashUtils.getApprovalHashBuffer(
+    ): Promise<SignedCoordinatorApproval> {
+        const approvalHashBuff = await hashUtils.getApprovalHashBufferAsync(
             transaction,
             this._verifyingContractAddress,
             txOrigin,
-            approvalExpirationTimeSeconds,
         );
         const signatureBuff = signingUtils.signMessage(approvalHashBuff, this._privateKey, signatureType);
         const signedApproval = {
             txOrigin,
             transaction,
-            approvalExpirationTimeSeconds,
-            signature: ethUtil.addHexPrefix(signatureBuff.toString('hex')),
+            signature: hexUtils.concat(signatureBuff),
         };
         return signedApproval;
     }

contracts/coordinator/src/artifacts.ts

@@ -7,7 +7,15 @@ import { ContractArtifact } from 'ethereum-types';
 
 import * as Coordinator from '../generated-artifacts/Coordinator.json';
 import * as CoordinatorRegistry from '../generated-artifacts/CoordinatorRegistry.json';
+import * as LibConstants from '../generated-artifacts/LibConstants.json';
+import * as LibCoordinatorApproval from '../generated-artifacts/LibCoordinatorApproval.json';
+import * as LibCoordinatorRichErrors from '../generated-artifacts/LibCoordinatorRichErrors.json';
+import * as LibEIP712CoordinatorDomain from '../generated-artifacts/LibEIP712CoordinatorDomain.json';
 export const artifacts = {
     Coordinator: Coordinator as ContractArtifact,
     CoordinatorRegistry: CoordinatorRegistry as ContractArtifact,
+    LibCoordinatorApproval: LibCoordinatorApproval as ContractArtifact,
+    LibCoordinatorRichErrors: LibCoordinatorRichErrors as ContractArtifact,
+    LibEIP712CoordinatorDomain: LibEIP712CoordinatorDomain as ContractArtifact,
+    LibConstants: LibConstants as ContractArtifact,
 };

contracts/coordinator/src/client/index.ts

@@ -0,0 +1,820 @@
+import { SendTransactionOpts } from '@0x/base-contract';
+import { getContractAddressesForChainOrThrow } from '@0x/contract-addresses';
+import { ExchangeContract } from '@0x/contracts-exchange';
+import { ExchangeFunctionName } from '@0x/contracts-test-utils';
+import { devConstants } from '@0x/dev-utils';
+import { schemas } from '@0x/json-schemas';
+import { generatePseudoRandomSalt, signatureUtils } from '@0x/order-utils';
+import { Order, SignedOrder, SignedZeroExTransaction, ZeroExTransaction } from '@0x/types';
+import { BigNumber, fetchAsync } from '@0x/utils';
+import { Web3Wrapper } from '@0x/web3-wrapper';
+import { CallData, ContractAbi, SupportedProvider, TxData } from 'ethereum-types';
+import * as HttpStatus from 'http-status-codes';
+import { flatten } from 'lodash';
+
+import { artifacts } from '../artifacts';
+import { CoordinatorContract, CoordinatorRegistryContract } from '../wrappers';
+
+import { assert } from './utils/assert';
+import {
+    CoordinatorServerApprovalResponse,
+    CoordinatorServerCancellationResponse,
+    CoordinatorServerError,
+    CoordinatorServerErrorMsg,
+    CoordinatorServerResponse,
+} from './utils/coordinator_server_types';
+
+import { decorators } from './utils/decorators';
+
+export { CoordinatorServerErrorMsg, CoordinatorServerCancellationResponse };
+
+const DEFAULT_TX_DATA = {
+    gas: devConstants.GAS_LIMIT,
+    gasPrice: new BigNumber(1),
+    value: new BigNumber(150000), // DEFAULT_PROTOCOL_FEE_MULTIPLIER
+};
+
+// tx expiration time will be set to (now + default_approval - time_buffer)
+const DEFAULT_APPROVAL_EXPIRATION_TIME_SECONDS = 90;
+const DEFAULT_EXPIRATION_TIME_BUFFER_SECONDS = 30;
+
+/**
+ * This class includes all the functionality related to filling or cancelling orders through
+ * the 0x V2 Coordinator extension contract.
+ */
+export class CoordinatorClient {
+    public abi: ContractAbi = artifacts.Coordinator.compilerOutput.abi;
+    public chainId: number;
+    public address: string;
+    public exchangeAddress: string;
+    public registryAddress: string;
+
+    private readonly _web3Wrapper: Web3Wrapper;
+    private readonly _contractInstance: CoordinatorContract;
+    private readonly _registryInstance: CoordinatorRegistryContract;
+    private readonly _exchangeInstance: ExchangeContract;
+    private readonly _feeRecipientToEndpoint: { [feeRecipient: string]: string } = {};
+    private readonly _txDefaults: CallData = DEFAULT_TX_DATA;
+
+    /**
+     * Validates that the 0x transaction has been approved by all of the feeRecipients that correspond to each order in the transaction's Exchange calldata.
+     * Throws an error if the transaction approvals are not valid. Will not detect failures that would occur when the transaction is executed on the Exchange contract.
+     * @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 approvalSignatures Array of signatures that correspond to the feeRecipients of each order in the transaction's Exchange calldata.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async assertValidCoordinatorApprovalsOrThrowAsync(
+        transaction: ZeroExTransaction,
+        txOrigin: string,
+        transactionSignature: string,
+        approvalSignatures: string[],
+    ): Promise<void> {
+        assert.doesConformToSchema('transaction', transaction, schemas.zeroExTransactionSchema);
+        assert.isETHAddressHex('txOrigin', txOrigin);
+        assert.isHexString('transactionSignature', transactionSignature);
+        for (const approvalSignature of approvalSignatures) {
+            assert.isHexString('approvalSignature', approvalSignature);
+        }
+        return this._contractInstance
+            .assertValidCoordinatorApprovals(transaction, txOrigin, transactionSignature, approvalSignatures)
+            .callAsync();
+    }
+    /**
+     * Instantiate CoordinatorClient
+     * @param web3Wrapper Web3Wrapper instance to use.
+     * @param chainId Desired chainId.
+     * @param address The address of the Coordinator contract. If undefined, will
+     * default to the known address corresponding to the chainId.
+     * @param exchangeAddress The address of the Exchange contract. If undefined, will
+     * default to the known address corresponding to the chainId.
+     * @param registryAddress The address of the CoordinatorRegistry contract. If undefined, will
+     * default to the known address corresponding to the chainId.
+     */
+    constructor(
+        address: string,
+        provider: SupportedProvider,
+        chainId: number,
+        txDefaults?: Partial<TxData>,
+        exchangeAddress?: string,
+        registryAddress?: string,
+    ) {
+        this.chainId = chainId;
+        const contractAddresses = getContractAddressesForChainOrThrow(this.chainId);
+        this.address = address === undefined ? contractAddresses.coordinator : address;
+        this.exchangeAddress = exchangeAddress === undefined ? contractAddresses.exchange : exchangeAddress;
+        this.registryAddress = registryAddress === undefined ? contractAddresses.coordinatorRegistry : registryAddress;
+        this._web3Wrapper = new Web3Wrapper(provider);
+        this._txDefaults = { ...txDefaults, ...DEFAULT_TX_DATA };
+        this._contractInstance = new CoordinatorContract(
+            this.address,
+            this._web3Wrapper.getProvider(),
+            this._web3Wrapper.getContractDefaults(),
+        );
+        this._registryInstance = new CoordinatorRegistryContract(
+            this.registryAddress,
+            this._web3Wrapper.getProvider(),
+            this._web3Wrapper.getContractDefaults(),
+        );
+        this._exchangeInstance = new ExchangeContract(
+            this.exchangeAddress,
+            this._web3Wrapper.getProvider(),
+            this._web3Wrapper.getContractDefaults(),
+        );
+    }
+
+    /**
+     * Fills a signed order with an amount denominated in baseUnits of the taker asset. Under-the-hood, this
+     * method uses the `feeRecipientAddress` of the order to look up the coordinator server endpoint registered in the
+     * coordinator registry contract. It requests an approval from that coordinator server before
+     * submitting the order and approval as a 0x transaction to the coordinator extension contract. The coordinator extension
+     * contract validates approvals and then fills the order via the Exchange contract.
+     * @param   order                   An object that conforms to the Order interface.
+     * @param   takerAssetFillAmount    The amount of the order (in taker asset baseUnits) that you wish to fill.
+     * @param   signature               Signature corresponding to the order.
+     * @param   txData                  Transaction data. The `from` field should be the user Ethereum address who would like
+     *                                  to fill these orders. Must be available via the Provider supplied at instantiation.
+     * @param   sendTxOpts              Optional arguments for sending the transaction.
+     * @return  Transaction hash.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async fillOrderAsync(
+        order: Order,
+        takerAssetFillAmount: BigNumber,
+        signature: string,
+        txData: TxData,
+        sendTxOpts: Partial<SendTransactionOpts> = { shouldValidate: true },
+    ): Promise<string> {
+        assert.doesConformToSchema('order', order, schemas.orderSchema);
+        assert.isValidBaseUnitAmount('takerAssetFillAmount', takerAssetFillAmount);
+        return this._executeTxThroughCoordinatorAsync(
+            ExchangeFunctionName.FillOrder,
+            txData,
+            sendTxOpts,
+            [order],
+            order,
+            takerAssetFillAmount,
+            signature,
+        );
+    }
+
+    /**
+     * Attempts to fill a specific amount of an order. If the entire amount specified cannot be filled,
+     * the fill order is abandoned.
+     * @param   order                   An object that conforms to the Order interface.
+     * @param   takerAssetFillAmount    The amount of the order (in taker asset baseUnits) that you wish to fill.
+     * @param   signature               Signature corresponding to the order.
+     * @param   txData                  Transaction data. The `from` field should be the user Ethereum address who would like
+     *                                  to fill these orders. Must be available via the Provider supplied at instantiation.
+     * @param   sendTxOpts              Optional arguments for sending the transaction.
+     * @return  Transaction hash.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async fillOrKillOrderAsync(
+        order: Order,
+        takerAssetFillAmount: BigNumber,
+        signature: string,
+        txData: TxData,
+        sendTxOpts: Partial<SendTransactionOpts> = { shouldValidate: true },
+    ): Promise<string> {
+        assert.doesConformToSchema('order', order, schemas.orderSchema);
+        assert.isValidBaseUnitAmount('takerAssetFillAmount', takerAssetFillAmount);
+        return this._executeTxThroughCoordinatorAsync(
+            ExchangeFunctionName.FillOrKillOrder,
+            txData,
+            sendTxOpts,
+            [order],
+            order,
+            takerAssetFillAmount,
+            signature,
+        );
+    }
+
+    /**
+     * Batch version of fillOrderAsync. Executes multiple fills atomically in a single transaction.
+     * If any `feeRecipientAddress` in the batch is not registered to a coordinator server through the CoordinatorRegistryContract, the whole batch fails.
+     * @param   orders                  An array of orders to fill.
+     * @param   takerAssetFillAmounts   The amounts of the orders (in taker asset baseUnits) that you wish to fill.
+     * @param   signatures              Signatures corresponding to the orders.
+     * @param   txData                  Transaction data. The `from` field should be the user Ethereum address who would like
+     *                                  to fill these orders. Must be available via the Provider supplied at instantiation.
+     * @param   sendTxOpts              Optional arguments for sending the transaction.
+     * @return  Transaction hash.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async batchFillOrdersAsync(
+        orders: Order[],
+        takerAssetFillAmounts: BigNumber[],
+        signatures: string[],
+        txData: TxData,
+        sendTxOpts?: Partial<SendTransactionOpts>,
+    ): Promise<string> {
+        return this._batchFillAsync(
+            ExchangeFunctionName.BatchFillOrders,
+            orders,
+            takerAssetFillAmounts,
+            signatures,
+            txData,
+            sendTxOpts,
+        );
+    }
+    /**
+     * No throw version of batchFillOrdersAsync
+     * @param   orders                  An array of orders to fill.
+     * @param   takerAssetFillAmounts   The amounts of the orders (in taker asset baseUnits) that you wish to fill.
+     * @param   signatures              Signatures corresponding to the orders.
+     * @param   txData                  Transaction data. The `from` field should be the user Ethereum address who would like
+     *                                  to fill these orders. Must be available via the Provider supplied at instantiation.
+     * @param   sendTxOpts              Optional arguments for sending the transaction.
+     * @return  Transaction hash.
+     */
+
+    public async batchFillOrdersNoThrowAsync(
+        orders: Order[],
+        takerAssetFillAmounts: BigNumber[],
+        signatures: string[],
+        txData: TxData,
+        sendTxOpts?: Partial<SendTransactionOpts>,
+    ): Promise<string> {
+        return this._batchFillAsync(
+            ExchangeFunctionName.BatchFillOrdersNoThrow,
+            orders,
+            takerAssetFillAmounts,
+            signatures,
+            txData,
+            sendTxOpts,
+        );
+    }
+    /**
+     * Batch version of fillOrKillOrderAsync. Executes multiple fills atomically in a single transaction.
+     * @param   orders                  An array of orders to fill.
+     * @param   takerAssetFillAmounts   The amounts of the orders (in taker asset baseUnits) that you wish to fill.
+     * @param   signatures              Signatures corresponding to the orders.
+     * @param   txData                  Transaction data. The `from` field should be the user Ethereum address who would like
+     *                                  to fill these orders. Must be available via the Provider supplied at instantiation.
+     * @param   sendTxOpts              Optional arguments for sending the transaction.
+     * @return  Transaction hash.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async batchFillOrKillOrdersAsync(
+        orders: Order[],
+        takerAssetFillAmounts: BigNumber[],
+        signatures: string[],
+        txData: TxData,
+        sendTxOpts?: Partial<SendTransactionOpts>,
+    ): Promise<string> {
+        return this._batchFillAsync(
+            ExchangeFunctionName.BatchFillOrKillOrders,
+            orders,
+            takerAssetFillAmounts,
+            signatures,
+            txData,
+            sendTxOpts,
+        );
+    }
+
+    /**
+     * Executes multiple calls of fillOrder until total amount of makerAsset is bought by taker.
+     * If any fill reverts, the error is caught and ignored. Finally, reverts if < makerAssetFillAmount has been bought.
+     * NOTE: This function does not enforce that the makerAsset is the same for each order.
+     * @param orders                Array of order specifications.
+     * @param makerAssetFillAmount  Desired amount of makerAsset to buy.
+     * @param signatures            Proofs that orders have been signed by makers.
+     * @param txData                Transaction data. The `from` field should be the user Ethereum address who would like
+     *                              to fill these orders. Must be available via the Provider supplied at instantiation.
+     * @param sendTxOpts            Optional arguments for sending the transaction.
+     * @return  Transaction hash.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async marketBuyOrdersFillOrKillAsync(
+        orders: Order[],
+        makerAssetFillAmount: BigNumber,
+        signatures: string[],
+        txData: TxData,
+        sendTxOpts: SendTransactionOpts = { shouldValidate: true },
+    ): Promise<string> {
+        return this._marketBuySellOrdersAsync(
+            ExchangeFunctionName.MarketBuyOrdersFillOrKill,
+            orders,
+            makerAssetFillAmount,
+            signatures,
+            txData,
+            sendTxOpts,
+        );
+    }
+
+    /**
+     * No throw version of marketBuyOrdersFillOrKillAsync
+     * @param   orders               An array of orders to fill.
+     * @param   makerAssetFillAmount Maker asset fill amount.
+     * @param   signatures           Signatures corresponding to the orders.
+     * @param   txData               Transaction data. The `from` field should be the user Ethereum address who would like
+     *                               to fill these orders. Must be available via the Provider supplied at instantiation.
+     * @param   sendTxOpts           Optional arguments for sending the transaction.
+     * @return  Transaction hash.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async marketBuyOrdersNoThrowAsync(
+        orders: Order[],
+        makerAssetFillAmount: BigNumber,
+        signatures: string[],
+        txData: TxData,
+        sendTxOpts: SendTransactionOpts = { shouldValidate: true },
+    ): Promise<string> {
+        return this._marketBuySellOrdersAsync(
+            ExchangeFunctionName.MarketBuyOrdersNoThrow,
+            orders,
+            makerAssetFillAmount,
+            signatures,
+            txData,
+            sendTxOpts,
+        );
+    }
+    /**
+     * Executes multiple calls of fillOrder until total amount of takerAsset is sold by taker.
+     * If any fill reverts, the error is caught and ignored. Finally, reverts if < takerAssetFillAmount has been sold.
+     * NOTE: This function does not enforce that the takerAsset is the same for each order.
+     * @param orders                 Array of order specifications.
+     * @param takerAssetFillAmount   Desired amount of takerAsset to sell.
+     * @param signatures             Proofs that orders have been signed by makers.
+     * @param txData                 Transaction data. The `from` field should be the user Ethereum address who would like
+     *                               to fill these orders. Must be available via the Provider supplied at instantiation.
+     * @param sendTxOpts             Optional arguments for sending the transaction.
+     * @return  Transaction hash.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async marketSellOrdersFillOrKillAsync(
+        orders: Order[],
+        takerAssetFillAmount: BigNumber,
+        signatures: string[],
+        txData: TxData,
+        sendTxOpts: SendTransactionOpts = { shouldValidate: true },
+    ): Promise<string> {
+        return this._marketBuySellOrdersAsync(
+            ExchangeFunctionName.MarketSellOrdersFillOrKill,
+            orders,
+            takerAssetFillAmount,
+            signatures,
+            txData,
+            sendTxOpts,
+        );
+    }
+
+    /**
+     * No throw version of marketSellOrdersAsync
+     * @param   orders               An array of orders to fill.
+     * @param   takerAssetFillAmount Taker asset fill amount.
+     * @param   signatures           Signatures corresponding to the orders.
+     * @param   txData               Transaction data. The `from` field should be the user Ethereum address who would like
+     *                               to fill these orders. Must be available via the Provider supplied at instantiation.
+     * @param   sendTxOpts           Optional arguments for sending the transaction.
+     * @return  Transaction hash.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async marketSellOrdersNoThrowAsync(
+        orders: Order[],
+        takerAssetFillAmount: BigNumber,
+        signatures: string[],
+        txData: TxData,
+        sendTxOpts: SendTransactionOpts = { shouldValidate: true },
+    ): Promise<string> {
+        return this._marketBuySellOrdersAsync(
+            ExchangeFunctionName.MarketSellOrdersNoThrow,
+            orders,
+            takerAssetFillAmount,
+            signatures,
+            txData,
+            sendTxOpts,
+        );
+    }
+
+    /**
+     * Cancels an order on-chain by submitting an Ethereum transaction.
+     * @param   order       An object that conforms to the Order interface. The order you would like to cancel.
+     * @param   txData      Transaction data. The `from` field should be the maker's Ethereum address. Must be available
+     *                      via the Provider supplied at instantiation.
+     * @param   sendTxOpts  Optional arguments for sending the transaction.
+     * @return  Transaction hash.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async hardCancelOrderAsync(
+        order: Order,
+        txData: TxData,
+        sendTxOpts: SendTransactionOpts = { shouldValidate: true },
+    ): Promise<string> {
+        assert.doesConformToSchema('order', order, schemas.orderSchema);
+        return this._executeTxThroughCoordinatorAsync(
+            ExchangeFunctionName.CancelOrder,
+            txData,
+            sendTxOpts,
+            [order],
+            order,
+        );
+    }
+
+    /**
+     * Batch version of hardCancelOrderAsync. Cancels orders on-chain by submitting an Ethereum transaction.
+     * Executes multiple cancels atomically in a single transaction.
+     * @param   orders      An array of orders to cancel.
+     * @param   txData      Transaction data. The `from` field should be the maker's Ethereum address. Must be available
+     *                      via the Provider supplied at instantiation.
+     * @param   sendTxOpts  Optional arguments for sending the transaction.
+     * @return  Transaction hash.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async batchHardCancelOrdersAsync(
+        orders: Order[],
+        txData: TxData,
+        sendTxOpts: SendTransactionOpts = { shouldValidate: true },
+    ): Promise<string> {
+        assert.doesConformToSchema('orders', orders, schemas.ordersSchema);
+        return this._executeTxThroughCoordinatorAsync(
+            ExchangeFunctionName.BatchCancelOrders,
+            txData,
+            sendTxOpts,
+            orders,
+            orders,
+        );
+    }
+
+    /**
+     * Cancels orders on-chain by submitting an Ethereum transaction.
+     * Cancels all orders created by makerAddress with a salt less than or equal to the targetOrderEpoch
+     * and senderAddress equal to coordinator extension contract address.
+     * @param   targetOrderEpoch    Target order epoch.
+     * @param   txData              Transaction data. The `from` field should be the maker's Ethereum address. Must be available
+     *                              via the Provider supplied at instantiation.
+     * @param   sendTxOpts          Optional arguments for sending the transaction.
+     * @return  Transaction hash.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async hardCancelOrdersUpToAsync(
+        targetOrderEpoch: BigNumber,
+        txData: TxData,
+        sendTxOpts: SendTransactionOpts = { shouldValidate: true },
+    ): Promise<string> {
+        assert.isBigNumber('targetOrderEpoch', targetOrderEpoch);
+        return this._executeTxThroughCoordinatorAsync(
+            ExchangeFunctionName.CancelOrdersUpTo,
+            txData,
+            sendTxOpts,
+            [],
+            targetOrderEpoch,
+        );
+    }
+    /**
+     * Soft cancel a given order.
+     * Soft cancels are recorded only on coordinator operator servers and do not involve an Ethereum transaction.
+     * See [soft cancels](https://github.com/0xProject/0x-protocol-specification/blob/master/v2/coordinator-specification.md#soft-cancels).
+     * @param   order           An object that conforms to the Order or SignedOrder interface. The order you would like to cancel.
+     * @return  CoordinatorServerCancellationResponse. See [Cancellation Response](https://github.com/0xProject/0x-protocol-specification/blob/master/v2/coordinator-specification.md#response).
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async softCancelAsync(order: Order): Promise<CoordinatorServerCancellationResponse> {
+        assert.doesConformToSchema('order', order, schemas.orderSchema);
+        assert.isETHAddressHex('feeRecipientAddress', order.feeRecipientAddress);
+        assert.isSenderAddressAsync('makerAddress', order.makerAddress, this._web3Wrapper);
+
+        const data = this._exchangeInstance.cancelOrder(order).getABIEncodedTransactionData();
+        const transaction = await this._generateSignedZeroExTransactionAsync(data, order.makerAddress);
+        const endpoint = await this._getServerEndpointOrThrowAsync(order);
+
+        const response = await this._executeServerRequestAsync(transaction, order.makerAddress, endpoint);
+        if (response.isError) {
+            const approvedOrders = new Array();
+            const cancellations = new Array();
+            const errors = [
+                {
+                    ...response,
+                    orders: [order],
+                },
+            ];
+            throw new CoordinatorServerError(
+                CoordinatorServerErrorMsg.CancellationFailed,
+                approvedOrders,
+                cancellations,
+                errors,
+            );
+        } else {
+            return response.body as CoordinatorServerCancellationResponse;
+        }
+    }
+    /**
+     * Batch version of softCancelOrderAsync. Requests multiple soft cancels
+     * @param   orders                An array of orders to cancel.
+     * @return  CoordinatorServerCancellationResponse. See [Cancellation Response](https://github.com/0xProject/0x-protocol-specification/blob/master/v2/coordinator-specification.md#response).
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async batchSoftCancelAsync(orders: SignedOrder[]): Promise<CoordinatorServerCancellationResponse[]> {
+        assert.doesConformToSchema('orders', orders, schemas.ordersSchema);
+        const makerAddress = getMakerAddressOrThrow(orders);
+        assert.isSenderAddressAsync('makerAddress', makerAddress, this._web3Wrapper);
+        const data = this._exchangeInstance.batchCancelOrders(orders).getABIEncodedTransactionData();
+        const transaction = await this._generateSignedZeroExTransactionAsync(data, makerAddress);
+
+        // make server requests
+        const errorResponses: CoordinatorServerResponse[] = [];
+        const successResponses: CoordinatorServerCancellationResponse[] = [];
+        const serverEndpointsToOrders = await this._mapServerEndpointsToOrdersAsync(orders);
+        for (const endpoint of Object.keys(serverEndpointsToOrders)) {
+            const response = await this._executeServerRequestAsync(transaction, makerAddress, endpoint);
+            if (response.isError) {
+                errorResponses.push(response);
+            } else {
+                successResponses.push(response.body as CoordinatorServerCancellationResponse);
+            }
+        }
+
+        // if no errors
+        if (errorResponses.length === 0) {
+            return successResponses;
+        } else {
+            // lookup orders with errors
+            const errorsWithOrders = errorResponses.map(resp => {
+                const endpoint = resp.coordinatorOperator;
+                const _orders = serverEndpointsToOrders[endpoint];
+                return {
+                    ...resp,
+                    orders: _orders,
+                };
+            });
+
+            const approvedOrders = new Array();
+            const cancellations = successResponses;
+            // return errors and approvals
+            throw new CoordinatorServerError(
+                CoordinatorServerErrorMsg.CancellationFailed,
+                approvedOrders,
+                cancellations,
+                errorsWithOrders,
+            );
+        }
+    }
+
+    /**
+     * 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.
+     * @returns Signer address.
+     */
+    @decorators.asyncZeroExErrorHandler
+    public async getSignerAddressAsync(hash: string, signature: string): Promise<string> {
+        assert.isHexString('hash', hash);
+        assert.isHexString('signature', signature);
+        const signerAddress = await this._contractInstance.getSignerAddress(hash, signature).callAsync();
+        return signerAddress;
+    }
+
+    private async _marketBuySellOrdersAsync(
+        exchangeFn: ExchangeFunctionName,
+        orders: Order[],
+        assetFillAmount: BigNumber,
+        signatures: string[],
+        txData: TxData,
+        sendTxOpts: SendTransactionOpts = { shouldValidate: true },
+    ): Promise<string> {
+        assert.doesConformToSchema('orders', orders, schemas.ordersSchema);
+        assert.isBigNumber('assetFillAmount', assetFillAmount);
+        return this._executeTxThroughCoordinatorAsync(
+            exchangeFn,
+            txData,
+            sendTxOpts,
+            orders,
+            orders,
+            assetFillAmount,
+            signatures,
+        );
+    }
+
+    private async _batchFillAsync(
+        exchangeFn: ExchangeFunctionName,
+        orders: Order[],
+        takerAssetFillAmounts: BigNumber[],
+        signatures: string[],
+        txData: TxData,
+        sendTxOpts: SendTransactionOpts = { shouldValidate: true },
+    ): Promise<string> {
+        assert.doesConformToSchema('orders', orders, schemas.ordersSchema);
+        takerAssetFillAmounts.forEach(takerAssetFillAmount =>
+            assert.isValidBaseUnitAmount('takerAssetFillAmount', takerAssetFillAmount),
+        );
+        return this._executeTxThroughCoordinatorAsync(
+            exchangeFn,
+            txData,
+            sendTxOpts,
+            orders,
+            orders,
+            takerAssetFillAmounts,
+            signatures,
+        );
+    }
+
+    private async _executeTxThroughCoordinatorAsync(
+        exchangeFn: ExchangeFunctionName,
+        txData: TxData,
+        sendTxOpts: Partial<SendTransactionOpts>,
+        ordersNeedingApprovals: Order[],
+        ...args: any[] // tslint:disable-line:trailing-comma
+    ): Promise<string> {
+        assert.isETHAddressHex('takerAddress', txData.from);
+        await assert.isSenderAddressAsync('takerAddress', txData.from, this._web3Wrapper);
+
+        // get ABI encoded transaction data for the desired exchange method
+        const data = (this._exchangeInstance as any)[exchangeFn](...args).getABIEncodedTransactionData();
+
+        // generate and sign a ZeroExTransaction
+        const signedZrxTx = await this._generateSignedZeroExTransactionAsync(data, txData.from, txData.gasPrice);
+
+        // get approval signatures from registered coordinator operators
+        const approvalSignatures = await this._getApprovalsAsync(signedZrxTx, ordersNeedingApprovals, txData.from);
+
+        // execute the transaction through the Coordinator Contract
+        const txDataWithDefaults = {
+            ...this._txDefaults,
+            ...txData, // override defaults
+        };
+        const txHash = this._contractInstance
+            .executeTransaction(signedZrxTx, txData.from, signedZrxTx.signature, approvalSignatures)
+            .sendTransactionAsync(txDataWithDefaults, sendTxOpts);
+        return txHash;
+    }
+
+    private async _generateSignedZeroExTransactionAsync(
+        data: string,
+        signerAddress: string,
+        gasPrice?: BigNumber | string | number,
+    ): Promise<SignedZeroExTransaction> {
+        const transaction: ZeroExTransaction = {
+            salt: generatePseudoRandomSalt(),
+            signerAddress,
+            data,
+            domain: {
+                verifyingContract: this.exchangeAddress,
+                chainId: await this._web3Wrapper.getChainIdAsync(),
+            },
+            expirationTimeSeconds: new BigNumber(
+                Math.floor(Date.now() / 1000) +
+                    DEFAULT_APPROVAL_EXPIRATION_TIME_SECONDS -
+                    DEFAULT_EXPIRATION_TIME_BUFFER_SECONDS,
+            ),
+            gasPrice: gasPrice ? new BigNumber(gasPrice) : new BigNumber(1),
+        };
+        const signedZrxTx = await signatureUtils.ecSignTransactionAsync(
+            this._web3Wrapper.getProvider(),
+            transaction,
+            transaction.signerAddress,
+        );
+        return signedZrxTx;
+    }
+
+    private async _getApprovalsAsync(
+        transaction: SignedZeroExTransaction,
+        orders: Order[],
+        txOrigin: string,
+    ): Promise<string[]> {
+        const coordinatorOrders = orders.filter(o => o.senderAddress === this.address);
+        if (coordinatorOrders.length === 0) {
+            return [];
+        }
+        const serverEndpointsToOrders = await this._mapServerEndpointsToOrdersAsync(coordinatorOrders);
+
+        // make server requests
+        const errorResponses: CoordinatorServerResponse[] = [];
+        const approvalResponses: CoordinatorServerResponse[] = [];
+        for (const endpoint of Object.keys(serverEndpointsToOrders)) {
+            const response = await this._executeServerRequestAsync(transaction, txOrigin, endpoint);
+            if (response.isError) {
+                errorResponses.push(response);
+            } else {
+                approvalResponses.push(response);
+            }
+        }
+
+        // if no errors
+        if (errorResponses.length === 0) {
+            // concatenate all approval responses
+            return approvalResponses.reduce(
+                (accumulator, response) =>
+                    accumulator.concat((response.body as CoordinatorServerApprovalResponse).signatures),
+                [] as string[],
+            );
+        } else {
+            // format errors and approvals
+            // concatenate approvals
+            const notCoordinatorOrders = orders.filter(o => o.senderAddress !== this.address);
+            const approvedOrdersNested = approvalResponses.map(resp => {
+                const endpoint = resp.coordinatorOperator;
+                return serverEndpointsToOrders[endpoint];
+            });
+            const approvedOrders = flatten(approvedOrdersNested.concat(notCoordinatorOrders));
+
+            // lookup orders with errors
+            const errorsWithOrders = errorResponses.map(resp => {
+                const endpoint = resp.coordinatorOperator;
+                return {
+                    ...resp,
+                    orders: serverEndpointsToOrders[endpoint],
+                };
+            });
+
+            // throw informative error
+            const cancellations = new Array();
+            throw new CoordinatorServerError(
+                CoordinatorServerErrorMsg.FillFailed,
+                approvedOrders,
+                cancellations,
+                errorsWithOrders,
+            );
+        }
+    }
+
+    private async _getServerEndpointOrThrowAsync(order: Order): Promise<string> {
+        const cached = this._feeRecipientToEndpoint[order.feeRecipientAddress];
+        const endpoint =
+            cached !== undefined
+                ? cached
+                : await _fetchServerEndpointOrThrowAsync(order.feeRecipientAddress, this._registryInstance);
+        return endpoint;
+
+        async function _fetchServerEndpointOrThrowAsync(
+            feeRecipient: string,
+            registryInstance: CoordinatorRegistryContract,
+        ): Promise<string> {
+            const coordinatorOperatorEndpoint = await registryInstance.getCoordinatorEndpoint(feeRecipient).callAsync();
+            if (coordinatorOperatorEndpoint === '' || coordinatorOperatorEndpoint === undefined) {
+                throw new Error(
+                    `No Coordinator server endpoint found in Coordinator Registry for feeRecipientAddress: ${feeRecipient}. Registry contract address: [${
+                        registryInstance.address
+                    }] Order: [${JSON.stringify(order)}]`,
+                );
+            }
+            return coordinatorOperatorEndpoint;
+        }
+    }
+
+    private async _executeServerRequestAsync(
+        signedTransaction: SignedZeroExTransaction,
+        txOrigin: string,
+        endpoint: string,
+    ): Promise<CoordinatorServerResponse> {
+        const requestPayload = {
+            signedTransaction,
+            txOrigin,
+        };
+        const response = await fetchAsync(`${endpoint}/v2/request_transaction?chainId=${this.chainId}`, {
+            body: JSON.stringify(requestPayload),
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json; charset=utf-8',
+            },
+        });
+
+        const isError = response.status !== HttpStatus.OK;
+        const isValidationError = response.status === HttpStatus.BAD_REQUEST;
+        const json = isError && !isValidationError ? undefined : await response.json();
+
+        const result = {
+            isError,
+            status: response.status,
+            body: isError ? undefined : json,
+            error: isError ? json : undefined,
+            request: requestPayload,
+            coordinatorOperator: endpoint,
+        };
+
+        return result;
+    }
+
+    private async _mapServerEndpointsToOrdersAsync(
+        coordinatorOrders: Order[],
+    ): Promise<{ [endpoint: string]: Order[] }> {
+        const groupByFeeRecipient: { [feeRecipient: string]: Order[] } = {};
+        for (const order of coordinatorOrders) {
+            const feeRecipient = order.feeRecipientAddress;
+            if (groupByFeeRecipient[feeRecipient] === undefined) {
+                groupByFeeRecipient[feeRecipient] = [] as Order[];
+            }
+            groupByFeeRecipient[feeRecipient].push(order);
+        }
+        const serverEndpointsToOrders: { [endpoint: string]: Order[] } = {};
+        for (const orders of Object.values(groupByFeeRecipient)) {
+            const endpoint = await this._getServerEndpointOrThrowAsync(orders[0]);
+            if (serverEndpointsToOrders[endpoint] === undefined) {
+                serverEndpointsToOrders[endpoint] = [];
+            }
+            serverEndpointsToOrders[endpoint] = serverEndpointsToOrders[endpoint].concat(orders);
+        }
+        return serverEndpointsToOrders;
+    }
+}
+
+function getMakerAddressOrThrow(orders: Array<Order | SignedOrder>): string {
+    const uniqueMakerAddresses = new Set(orders.map(o => o.makerAddress));
+    if (uniqueMakerAddresses.size > 1) {
+        throw new Error(`All orders in a batch must have the same makerAddress`);
+    }
+    return orders[0].makerAddress;
+}
+
+// tslint:disable:max-file-line-count

contracts/coordinator/src/client/utils/assert.ts

@@ -0,0 +1,22 @@
+import { assert as sharedAssert } from '@0x/assert';
+// HACK: We need those two unused imports because they're actually used by sharedAssert which gets injected here
+import { Schema } from '@0x/json-schemas'; // tslint:disable-line:no-unused-variable
+import { Order } from '@0x/types'; // tslint:disable-line:no-unused-variable
+import { BigNumber } from '@0x/utils'; // tslint:disable-line:no-unused-variable
+import { Web3Wrapper } from '@0x/web3-wrapper';
+
+export const assert = {
+    ...sharedAssert,
+    async isSenderAddressAsync(
+        variableName: string,
+        senderAddressHex: string,
+        web3Wrapper: Web3Wrapper,
+    ): Promise<void> {
+        sharedAssert.isETHAddressHex(variableName, senderAddressHex);
+        const isSenderAddressAvailable = await web3Wrapper.isSenderAddressAvailableAsync(senderAddressHex);
+        sharedAssert.assert(
+            isSenderAddressAvailable,
+            `Specified ${variableName} ${senderAddressHex} isn't available through the supplied web3 provider`,
+        );
+    },
+};

contracts/coordinator/src/client/utils/coordinator_server_types.ts

@@ -2,10 +2,6 @@ import { Order, SignedOrder, SignedZeroExTransaction } from '@0x/types';
 import { BigNumber } from '@0x/utils';
 
 export interface CoordinatorServerApprovalResponse {
-    signatures: string[];
-    expirationTimeSeconds: BigNumber[];
-}
-export interface CoordinatorServerApprovalRawResponse {
     signatures: string[];
     expirationTimeSeconds: BigNumber;
 }
@@ -24,7 +20,7 @@ export interface CoordinatorOutstandingFillSignatures {
 export interface CoordinatorServerResponse {
     isError: boolean;
     status: number;
-    body?: CoordinatorServerCancellationResponse | CoordinatorServerApprovalRawResponse;
+    body?: CoordinatorServerCancellationResponse | CoordinatorServerApprovalResponse;
     error?: any;
     request: CoordinatorServerRequest;
     coordinatorOperator: string;
@@ -38,12 +34,12 @@ export interface CoordinatorServerRequest {
 
 export class CoordinatorServerError extends Error {
     public message: CoordinatorServerErrorMsg;
-    public approvedOrders?: SignedOrder[] = [];
+    public approvedOrders?: Order[] = [];
     public cancellations?: CoordinatorServerCancellationResponse[] = [];
     public errors: CoordinatorServerResponse[];
     constructor(
         message: CoordinatorServerErrorMsg,
-        approvedOrders: SignedOrder[],
+        approvedOrders: Order[],
         cancellations: CoordinatorServerCancellationResponse[],
         errors: CoordinatorServerResponse[],
     ) {

contracts/coordinator/src/client/utils/decorators.ts

@@ -1,7 +1,7 @@
 import * as _ from 'lodash';
 
 export enum ContractError {
-    ContractNotDeployedOnNetwork = 'CONTRACT_NOT_DEPLOYED_ON_NETWORK',
+    ContractNotDeployedOnChain = 'CONTRACT_NOT_DEPLOYED_ON_CHAIN',
     InsufficientAllowanceForTransfer = 'INSUFFICIENT_ALLOWANCE_FOR_TRANSFER',
     InsufficientBalanceForTransfer = 'INSUFFICIENT_BALANCE_FOR_TRANSFER',
     InsufficientEthBalanceForDeposit = 'INSUFFICIENT_ETH_BALANCE_FOR_DEPOSIT',

contracts/coordinator/src/hash_utils.ts

@@ -1,33 +1,29 @@
 import { eip712Utils } from '@0x/order-utils';
 import { SignedZeroExTransaction } from '@0x/types';
-import { BigNumber, signTypedDataUtils } from '@0x/utils';
-import * as _ from 'lodash';
+import { hexUtils, signTypedDataUtils } from '@0x/utils';
 
 export const hashUtils = {
-    getApprovalHashBuffer(
+    async getApprovalHashBufferAsync(
         transaction: SignedZeroExTransaction,
         verifyingContract: string,
         txOrigin: string,
-        approvalExpirationTimeSeconds: BigNumber,
-    ): Buffer {
-        const typedData = eip712Utils.createCoordinatorApprovalTypedData(
+    ): Promise<Buffer> {
+        const typedData = await eip712Utils.createCoordinatorApprovalTypedDataAsync(
             transaction,
             verifyingContract,
             txOrigin,
-            approvalExpirationTimeSeconds,
         );
         const hashBuffer = signTypedDataUtils.generateTypedDataHash(typedData);
         return hashBuffer;
     },
-    getApprovalHashHex(
+    async getApprovalHashHexAsync(
         transaction: SignedZeroExTransaction,
         verifyingContract: string,
         txOrigin: string,
-        approvalExpirationTimeSeconds: BigNumber,
-    ): string {
-        const hashHex = `0x${hashUtils
-            .getApprovalHashBuffer(transaction, verifyingContract, txOrigin, approvalExpirationTimeSeconds)
-            .toString('hex')}`;
+    ): Promise<string> {
+        const hashHex = hexUtils.concat(
+            await hashUtils.getApprovalHashBufferAsync(transaction, verifyingContract, txOrigin),
+        );
         return hashHex;
     },
 };

contracts/coordinator/src/index.ts

@@ -1,3 +1,66 @@
-export * from './artifacts';
-export * from './wrappers';
-export * from '../test/utils';
+export { artifacts } from './artifacts';
+export {
+    CoordinatorContract,
+    CoordinatorRegistryContract,
+    LibConstantsContract,
+    LibCoordinatorApprovalContract,
+    LibCoordinatorRichErrorsContract,
+    LibEIP712CoordinatorDomainContract,
+} from './wrappers';
+export { CoordinatorRevertErrors } from '@0x/utils';
+export { CoordinatorServerCancellationResponse } from './client/index';
+export { ApprovalFactory } from './approval_factory';
+export { SignedCoordinatorApproval } from './types';
+export {
+    Order,
+    SignedOrder,
+    SignatureType,
+    SignedZeroExTransaction,
+    EIP712DomainWithDefaultSchema,
+    ZeroExTransaction,
+} from '@0x/types';
+export { AwaitTransactionSuccessOpts, SendTransactionOpts } from '@0x/base-contract';
+export {
+    ContractArtifact,
+    ContractChains,
+    CompilerOpts,
+    StandardContractOutput,
+    CompilerSettings,
+    ContractChainData,
+    ContractAbi,
+    DevdocOutput,
+    EvmOutput,
+    CompilerSettingsMetadata,
+    OptimizerSettings,
+    OutputField,
+    ParamDescription,
+    EvmBytecodeOutput,
+    AbiDefinition,
+    FunctionAbi,
+    EventAbi,
+    RevertErrorAbi,
+    EventParameter,
+    DataItem,
+    MethodAbi,
+    ConstructorAbi,
+    FallbackAbi,
+    ConstructorStateMutability,
+    TupleDataItem,
+    StateMutability,
+    SupportedProvider,
+    TxData,
+    TxDataPayable,
+    Web3JsProvider,
+    GanacheProvider,
+    EIP1193Provider,
+    ZeroExProvider,
+    EIP1193Event,
+    JSONRPCRequestPayload,
+    JSONRPCErrorCallback,
+    Web3JsV1Provider,
+    Web3JsV2Provider,
+    Web3JsV3Provider,
+    JSONRPCResponsePayload,
+    JSONRPCResponseError,
+} from 'ethereum-types';
+export { CoordinatorClient, CoordinatorServerErrorMsg } from './client/index';

contracts/coordinator/src/types.ts

@@ -4,9 +4,14 @@ import { BigNumber } from '@0x/utils';
 export interface CoordinatorApproval {
     transaction: SignedZeroExTransaction;
     txOrigin: string;
-    approvalExpirationTimeSeconds: BigNumber;
 }
 
 export interface SignedCoordinatorApproval extends CoordinatorApproval {
     signature: string;
 }
+
+export interface CoordinatorTransaction {
+    salt: BigNumber;
+    signerAddress: string;
+    data: string;
+}

contracts/coordinator/src/wrappers.ts

@@ -5,3 +5,7 @@
  */
 export * from '../generated-wrappers/coordinator';
 export * from '../generated-wrappers/coordinator_registry';
+export * from '../generated-wrappers/lib_constants';
+export * from '../generated-wrappers/lib_coordinator_approval';
+export * from '../generated-wrappers/lib_coordinator_rich_errors';
+export * from '../generated-wrappers/lib_e_i_p712_coordinator_domain';

contracts/coordinator/test/artifacts.ts

@@ -0,0 +1,37 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+import { ContractArtifact } from 'ethereum-types';
+
+import * as Coordinator from '../test/generated-artifacts/Coordinator.json';
+import * as CoordinatorRegistry from '../test/generated-artifacts/CoordinatorRegistry.json';
+import * as ICoordinatorApprovalVerifier from '../test/generated-artifacts/ICoordinatorApprovalVerifier.json';
+import * as ICoordinatorCore from '../test/generated-artifacts/ICoordinatorCore.json';
+import * as ICoordinatorRegistryCore from '../test/generated-artifacts/ICoordinatorRegistryCore.json';
+import * as ICoordinatorSignatureValidator from '../test/generated-artifacts/ICoordinatorSignatureValidator.json';
+import * as LibConstants from '../test/generated-artifacts/LibConstants.json';
+import * as LibCoordinatorApproval from '../test/generated-artifacts/LibCoordinatorApproval.json';
+import * as LibCoordinatorRichErrors from '../test/generated-artifacts/LibCoordinatorRichErrors.json';
+import * as LibEIP712CoordinatorDomain from '../test/generated-artifacts/LibEIP712CoordinatorDomain.json';
+import * as MixinCoordinatorApprovalVerifier from '../test/generated-artifacts/MixinCoordinatorApprovalVerifier.json';
+import * as MixinCoordinatorCore from '../test/generated-artifacts/MixinCoordinatorCore.json';
+import * as MixinCoordinatorRegistryCore from '../test/generated-artifacts/MixinCoordinatorRegistryCore.json';
+import * as MixinSignatureValidator from '../test/generated-artifacts/MixinSignatureValidator.json';
+export const artifacts = {
+    Coordinator: Coordinator as ContractArtifact,
+    MixinCoordinatorApprovalVerifier: MixinCoordinatorApprovalVerifier as ContractArtifact,
+    MixinCoordinatorCore: MixinCoordinatorCore as ContractArtifact,
+    MixinSignatureValidator: MixinSignatureValidator as ContractArtifact,
+    ICoordinatorApprovalVerifier: ICoordinatorApprovalVerifier as ContractArtifact,
+    ICoordinatorCore: ICoordinatorCore as ContractArtifact,
+    ICoordinatorSignatureValidator: ICoordinatorSignatureValidator as ContractArtifact,
+    LibConstants: LibConstants as ContractArtifact,
+    LibCoordinatorApproval: LibCoordinatorApproval as ContractArtifact,
+    LibCoordinatorRichErrors: LibCoordinatorRichErrors as ContractArtifact,
+    LibEIP712CoordinatorDomain: LibEIP712CoordinatorDomain as ContractArtifact,
+    CoordinatorRegistry: CoordinatorRegistry as ContractArtifact,
+    MixinCoordinatorRegistryCore: MixinCoordinatorRegistryCore as ContractArtifact,
+    ICoordinatorRegistryCore: ICoordinatorRegistryCore as ContractArtifact,
+};

contracts/coordinator/test/coordinator.ts

@@ -1,531 +0,0 @@
-import { ERC20ProxyContract, ERC20Wrapper } from '@0x/contracts-asset-proxy';
-import { DummyERC20TokenContract } from '@0x/contracts-erc20';
-import {
-    artifacts as exchangeArtifacts,
-    constants as exchangeConstants,
-    ExchangeCancelEventArgs,
-    ExchangeCancelUpToEventArgs,
-    ExchangeContract,
-    exchangeDataEncoder,
-    ExchangeFillEventArgs,
-    ExchangeFunctionName,
-} from '@0x/contracts-exchange';
-import {
-    chaiSetup,
-    constants,
-    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 } from '@0x/types';
-import { BigNumber, providerUtils } from '@0x/utils';
-import * as chai from 'chai';
-import { LogWithDecodedArgs } from 'ethereum-types';
-
-import { ApprovalFactory, artifacts, CoordinatorContract } 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 chainId: number;
-    let makerAddress: string;
-    let owner: string;
-    let takerAddress: string;
-    let feeRecipientAddress: string;
-
-    let erc20Proxy: ERC20ProxyContract;
-    let erc20TokenA: DummyERC20TokenContract;
-    let erc20TokenB: DummyERC20TokenContract;
-    let makerFeeToken: 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 () => {
-        chainId = await providerUtils.getChainIdAsync(provider);
-        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, makerFeeToken] = await erc20Wrapper.deployDummyTokensAsync(
-            numDummyErc20ToDeploy,
-            constants.DUMMY_TOKEN_DECIMALS,
-        );
-        await erc20Wrapper.setBalancesAndAllowancesAsync();
-
-        exchange = await ExchangeContract.deployFrom0xArtifactAsync(
-            exchangeArtifacts.Exchange,
-            provider,
-            txDefaults,
-            new BigNumber(chainId),
-        );
-
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await erc20Proxy.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: owner }),
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
-
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await exchange.registerAssetProxy.sendTransactionAsync(erc20Proxy.address, { from: owner }),
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
-
-        coordinatorContract = await CoordinatorContract.deployFrom0xArtifactAsync(
-            artifacts.Coordinator,
-            provider,
-            txDefaults,
-            artifacts,
-            exchange.address,
-            new BigNumber(chainId),
-        );
-
-        // Configure order defaults
-        const defaultOrderParams = {
-            ...constants.STATIC_ORDER_PARAMS,
-            senderAddress: coordinatorContract.address,
-            makerAddress,
-            feeRecipientAddress,
-            makerAssetData: assetDataUtils.encodeERC20AssetData(erc20TokenA.address),
-            takerAssetData: assetDataUtils.encodeERC20AssetData(erc20TokenB.address),
-            makerFeeAssetData: assetDataUtils.encodeERC20AssetData(makerFeeToken.address),
-            takerFeeAssetData: assetDataUtils.encodeERC20AssetData(makerFeeToken.address),
-            exchangeAddress: exchange.address,
-            chainId,
-        };
-        const makerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
-        const takerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(takerAddress)];
-        const feeRecipientPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(feeRecipientAddress)];
-        orderFactory = new OrderFactory(makerPrivateKey, defaultOrderParams);
-        makerTransactionFactory = new TransactionFactory(makerPrivateKey, exchange.address, chainId);
-        takerTransactionFactory = new TransactionFactory(takerPrivateKey, exchange.address, chainId);
-        approvalFactory = new ApprovalFactory(feeRecipientPrivateKey, coordinatorContract.address);
-    });
-    beforeEach(async () => {
-        await blockchainLifecycle.startAsync();
-    });
-    afterEach(async () => {
-        await blockchainLifecycle.revertAsync();
-    });
-
-    describe('single order fills', () => {
-        for (const fnName of exchangeConstants.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 = await takerTransactionFactory.newSignedTransactionAsync({ 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 },
-                    ),
-                    constants.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 = await takerTransactionFactory.newSignedTransactionAsync({ data });
-                const transactionReceipt = await web3Wrapper.awaitTransactionSuccessAsync(
-                    await coordinatorContract.executeTransaction.sendTransactionAsync(
-                        transaction,
-                        feeRecipientAddress,
-                        transaction.signature,
-                        [],
-                        [],
-                        { from: feeRecipientAddress },
-                    ),
-                    constants.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 = await takerTransactionFactory.newSignedTransactionAsync({ data });
-                await expectTransactionFailedAsync(
-                    coordinatorContract.executeTransaction.sendTransactionAsync(
-                        transaction,
-                        takerAddress,
-                        transaction.signature,
-                        [],
-                        [],
-                        {
-                            from: takerAddress,
-                            gas: constants.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 = await takerTransactionFactory.newSignedTransactionAsync({ 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 = await takerTransactionFactory.newSignedTransactionAsync({ 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 = await takerTransactionFactory.newSignedTransactionAsync({ 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 [...exchangeConstants.MARKET_FILL_FN_NAMES, ...exchangeConstants.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 = await takerTransactionFactory.newSignedTransactionAsync({ 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: constants.MAX_EXECUTE_TRANSACTION_GAS },
-                    ),
-                    constants.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 = await takerTransactionFactory.newSignedTransactionAsync({ data });
-                const transactionReceipt = await web3Wrapper.awaitTransactionSuccessAsync(
-                    await coordinatorContract.executeTransaction.sendTransactionAsync(
-                        transaction,
-                        feeRecipientAddress,
-                        transaction.signature,
-                        [],
-                        [],
-                        { from: feeRecipientAddress, gas: constants.MAX_EXECUTE_TRANSACTION_GAS },
-                    ),
-                    constants.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 = await takerTransactionFactory.newSignedTransactionAsync({ 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 = await takerTransactionFactory.newSignedTransactionAsync({ 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 = await takerTransactionFactory.newSignedTransactionAsync({ 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(ExchangeFunctionName.CancelOrder, orders);
-            const transaction = await makerTransactionFactory.newSignedTransactionAsync({ 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(ExchangeFunctionName.BatchCancelOrders, orders);
-            const transaction = await makerTransactionFactory.newSignedTransactionAsync({ 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 targetEpoch = constants.ZERO_AMOUNT;
-            const data = exchange.cancelOrdersUpTo.getABIEncodedTransactionData(targetEpoch);
-            const transaction = await makerTransactionFactory.newSignedTransactionAsync({ 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.orderSenderAddress).to.eq(coordinatorContract.address);
-            expect(cancelLogArgs.orderEpoch).to.bignumber.eq(targetEpoch.plus(1));
-        });
-    });
-});
-// tslint:disable:max-file-line-count

contracts/coordinator/test/coordinator_registry.ts

@@ -1,81 +1,73 @@
-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 { blockchainTests, expect, verifyEvents } from '@0x/contracts-test-utils';
 
-import { CoordinatorRegistryCoordinatorEndpointSetEventArgs } from '../src';
+import { artifacts } from './artifacts';
 
-import { CoordinatorRegistryWrapper } from './utils/coordinator_registry_wrapper';
+import { CoordinatorRegistryContract, CoordinatorRegistryCoordinatorEndpointSetEventArgs } from './wrappers';
 
-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', () => {
+blockchainTests.resets('Coordinator Registry tests', env => {
+    let coordinatorRegistry: CoordinatorRegistryContract;
     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();
+        const accounts = await env.getAccountAddressesAsync();
         [, coordinatorOperator] = accounts;
         // deploy coordinator registry
-        coordinatorRegistryWrapper = new CoordinatorRegistryWrapper(provider);
-        await coordinatorRegistryWrapper.deployCoordinatorRegistryAsync();
-    });
-    beforeEach(async () => {
-        await blockchainLifecycle.startAsync();
-    });
-    afterEach(async () => {
-        await blockchainLifecycle.revertAsync();
+        coordinatorRegistry = await CoordinatorRegistryContract.deployFrom0xArtifactAsync(
+            artifacts.CoordinatorRegistry,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+        );
     });
     describe('core', () => {
         it('Should successfully set a Coordinator endpoint', async () => {
-            await coordinatorRegistryWrapper.setCoordinatorEndpointAsync(coordinatorOperator, coordinatorEndpoint);
-            const recordedCoordinatorEndpoint = await coordinatorRegistryWrapper.getCoordinatorEndpointAsync(
-                coordinatorOperator,
-            );
+            await coordinatorRegistry.setCoordinatorEndpoint(coordinatorEndpoint).awaitTransactionSuccessAsync({
+                from: coordinatorOperator,
+            });
+            const recordedCoordinatorEndpoint = await coordinatorRegistry
+                .getCoordinatorEndpoint(coordinatorOperator)
+                .callAsync();
             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,
-            );
+            await coordinatorRegistry.setCoordinatorEndpoint(coordinatorEndpoint).awaitTransactionSuccessAsync({
+                from: coordinatorOperator,
+            });
+            let recordedCoordinatorEndpoint = await coordinatorRegistry
+                .getCoordinatorEndpoint(coordinatorOperator)
+                .callAsync();
             expect(recordedCoordinatorEndpoint).to.be.equal(coordinatorEndpoint);
             // unset Coordinator endpoint
-            await coordinatorRegistryWrapper.setCoordinatorEndpointAsync(coordinatorOperator, nilCoordinatorEndpoint);
-            recordedCoordinatorEndpoint = await coordinatorRegistryWrapper.getCoordinatorEndpointAsync(
-                coordinatorOperator,
-            );
+            await coordinatorRegistry.setCoordinatorEndpoint(nilCoordinatorEndpoint).awaitTransactionSuccessAsync({
+                from: coordinatorOperator,
+            });
+            recordedCoordinatorEndpoint = await coordinatorRegistry
+                .getCoordinatorEndpoint(coordinatorOperator)
+                .callAsync();
             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,
-            );
+            const txReceipt = await coordinatorRegistry
+                .setCoordinatorEndpoint(coordinatorEndpoint)
+                .awaitTransactionSuccessAsync({
+                    from: coordinatorOperator,
+                });
+            const recordedCoordinatorEndpoint = await coordinatorRegistry
+                .getCoordinatorEndpoint(coordinatorOperator)
+                .callAsync();
             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);
+            const expectedEvent: CoordinatorRegistryCoordinatorEndpointSetEventArgs = {
+                coordinatorOperator,
+                coordinatorEndpoint,
+            };
+            verifyEvents(txReceipt, [expectedEvent], 'CoordinatorEndpointSet');
         });
     });
 });

contracts/coordinator/test/libs.ts

@@ -1,67 +1,35 @@
-import { chaiSetup, constants, provider, randomAddress, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
-import { BlockchainLifecycle } from '@0x/dev-utils';
-import { transactionHashUtils } from '@0x/order-utils';
-import { BigNumber, providerUtils } from '@0x/utils';
-import * as chai from 'chai';
+import { blockchainTests, constants, expect, randomAddress, transactionHashUtils } from '@0x/contracts-test-utils';
+import { BigNumber } from '@0x/utils';
 
-import { artifacts, CoordinatorContract, hashUtils } from '../src';
+import { hashUtils } from '../src/hash_utils';
 
-chaiSetup.configure();
-const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+import { artifacts } from './artifacts';
 
-describe('Libs tests', () => {
+import { CoordinatorContract } from './wrappers';
+
+blockchainTests.resets('Libs tests', env => {
     let coordinatorContract: CoordinatorContract;
     let chainId: number;
     const exchangeAddress = randomAddress();
 
     before(async () => {
-        await blockchainLifecycle.startAsync();
-    });
-    after(async () => {
-        await blockchainLifecycle.revertAsync();
-    });
-    before(async () => {
-        chainId = await providerUtils.getChainIdAsync(provider);
+        chainId = await env.getChainIdAsync();
         coordinatorContract = await CoordinatorContract.deployFrom0xArtifactAsync(
             artifacts.Coordinator,
-            provider,
-            txDefaults,
+            env.provider,
+            env.txDefaults,
             artifacts,
             exchangeAddress,
             new BigNumber(chainId),
         );
     });
-    beforeEach(async () => {
-        await blockchainLifecycle.startAsync();
-    });
-    afterEach(async () => {
-        await blockchainLifecycle.revertAsync();
-    });
-
-    describe('getTransactionHash', () => {
-        it('should return the correct transaction hash', async () => {
-            const tx = {
-                salt: new BigNumber(0),
-                expirationTimeSeconds: new BigNumber(0),
-                signerAddress: constants.NULL_ADDRESS,
-                data: '0x1234',
-                domain: {
-                    verifyingContract: exchangeAddress,
-                    chainId,
-                },
-            };
-            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 = {
-                salt: new BigNumber(0),
-                expirationTimeSeconds: new BigNumber(0),
+                salt: constants.ZERO_AMOUNT,
+                gasPrice: constants.ZERO_AMOUNT,
+                expirationTimeSeconds: constants.ZERO_AMOUNT,
                 signerAddress: constants.NULL_ADDRESS,
                 data: '0x1234',
                 signature: '0x5678',
@@ -70,21 +38,18 @@ describe('Libs tests', () => {
                     chainId,
                 },
             };
-            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(
+            const expectedApprovalHash = await hashUtils.getApprovalHashHexAsync(
                 signedTx,
                 coordinatorContract.address,
                 txOrigin,
-                approvalExpirationTimeSeconds,
             );
-            const approvalHash = await coordinatorContract.getCoordinatorApprovalHash.callAsync(approval);
+            const approvalHash = await coordinatorContract.getCoordinatorApprovalHash(approval).callAsync();
             expect(expectedApprovalHash).to.eq(approvalHash);
         });
     });

contracts/coordinator/test/mixins.ts

@@ -1,29 +1,24 @@
-import { constants as exchangeConstants, exchangeDataEncoder, ExchangeFunctionName } from '@0x/contracts-exchange';
+import { exchangeDataEncoder } from '@0x/contracts-exchange';
 import {
-    chaiSetup,
+    blockchainTests,
     constants,
-    expectContractCallFailedAsync,
-    getLatestBlockTimestampAsync,
-    provider,
+    ExchangeFunctionName,
+    expect,
     randomAddress,
     TransactionFactory,
-    txDefaults,
-    web3Wrapper,
+    transactionHashUtils,
 } 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, LibBytesRevertErrors, providerUtils } from '@0x/utils';
-import * as chai from 'chai';
-import * as ethUtil from 'ethereumjs-util';
+import { LibBytesRevertErrors } from '@0x/contracts-utils';
+import { SignatureType, SignedOrder } from '@0x/types';
+import { BigNumber, CoordinatorRevertErrors, hexUtils } from '@0x/utils';
 
-import { ApprovalFactory, artifacts, CoordinatorContract } from '../src';
+import { ApprovalFactory } from '../src/approval_factory';
 
-chaiSetup.configure();
-const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+import { artifacts } from './artifacts';
 
-describe('Mixins tests', () => {
+import { CoordinatorContract } from './wrappers';
+
+blockchainTests.resets('Mixins tests', env => {
     let chainId: number;
     let transactionSignerAddress: string;
     let approvalSignerAddress1: string;
@@ -36,23 +31,17 @@ describe('Mixins tests', () => {
     const exchangeAddress = randomAddress();
 
     before(async () => {
-        await blockchainLifecycle.startAsync();
-    });
-    after(async () => {
-        await blockchainLifecycle.revertAsync();
-    });
-    before(async () => {
-        chainId = await providerUtils.getChainIdAsync(provider);
+        chainId = await env.getChainIdAsync();
         mixins = await CoordinatorContract.deployFrom0xArtifactAsync(
             artifacts.Coordinator,
-            provider,
-            txDefaults,
+            env.provider,
+            env.txDefaults,
             artifacts,
             exchangeAddress,
             new BigNumber(chainId),
         );
-        const accounts = await web3Wrapper.getAvailableAddressesAsync();
-        [transactionSignerAddress, approvalSignerAddress1, approvalSignerAddress2] = accounts.slice(0, 3);
+        const accounts = await env.getAccountAddressesAsync();
+        [transactionSignerAddress, approvalSignerAddress1, approvalSignerAddress2] = accounts;
         defaultOrder = {
             makerAddress: constants.NULL_ADDRESS,
             takerAddress: constants.NULL_ADDRESS,
@@ -79,72 +68,91 @@ describe('Mixins tests', () => {
         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 = constants.NULL_BYTES;
             const transaction = await transactionFactory.newSignedTransactionAsync({ data }, SignatureType.EthSign);
             const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
-            const signerAddress = await mixins.getSignerAddress.callAsync(transactionHash, transaction.signature);
+            const signerAddress = await mixins.getSignerAddress(transactionHash, transaction.signature).callAsync();
             expect(transaction.signerAddress).to.eq(signerAddress);
         });
         it('should return the correct address using the EIP712 signature type', async () => {
             const data = constants.NULL_BYTES;
             const transaction = await transactionFactory.newSignedTransactionAsync({ data }, SignatureType.EIP712);
             const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
-            const signerAddress = await mixins.getSignerAddress.callAsync(transactionHash, transaction.signature);
+            const signerAddress = await mixins.getSignerAddress(transactionHash, transaction.signature).callAsync();
             expect(transaction.signerAddress).to.eq(signerAddress);
         });
         it('should revert with with the Illegal signature type', async () => {
             const data = constants.NULL_BYTES;
             const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-            const illegalSignatureByte = ethUtil.toBuffer(SignatureType.Illegal).toString('hex');
-            transaction.signature = `${transaction.signature.slice(
-                0,
-                transaction.signature.length - 2,
-            )}${illegalSignatureByte}`;
+            transaction.signature = hexUtils.concat(
+                hexUtils.slice(transaction.signature, 0, transaction.signature.length - 1),
+                SignatureType.Illegal,
+            );
             const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
-            expect(mixins.getSignerAddress.callAsync(transactionHash, transaction.signature)).to.be.rejectedWith(
-                RevertReason.SignatureIllegal,
+            expect(mixins.getSignerAddress(transactionHash, transaction.signature).callAsync()).to.revertWith(
+                new CoordinatorRevertErrors.SignatureError(
+                    CoordinatorRevertErrors.SignatureErrorCodes.Illegal,
+                    transactionHash,
+                    transaction.signature,
+                ),
             );
         });
         it('should revert with with the Invalid signature type', async () => {
             const data = constants.NULL_BYTES;
             const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-            const invalidSignatureByte = ethUtil.toBuffer(SignatureType.Invalid).toString('hex');
-            transaction.signature = `0x${invalidSignatureByte}`;
+            transaction.signature = hexUtils.concat(SignatureType.Invalid);
             const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
-            expect(mixins.getSignerAddress.callAsync(transactionHash, transaction.signature)).to.be.rejectedWith(
-                RevertReason.SignatureInvalid,
+            expect(mixins.getSignerAddress(transactionHash, transaction.signature).callAsync()).to.revertWith(
+                new CoordinatorRevertErrors.SignatureError(
+                    CoordinatorRevertErrors.SignatureErrorCodes.Invalid,
+                    transactionHash,
+                    transaction.signature,
+                ),
             );
         });
-        it("should revert with with a signature type that doesn't exist", async () => {
+        it('should revert with with a signature type that equals `NSignatureTypes`', async () => {
             const data = constants.NULL_BYTES;
             const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-            const invalidSignatureByte = '04';
-            transaction.signature = `${transaction.signature.slice(
-                0,
-                transaction.signature.length - 2,
-            )}${invalidSignatureByte}`;
+            transaction.signature = hexUtils.concat(
+                hexUtils.slice(transaction.signature, 0, transaction.signature.length - 1),
+                SignatureType.NSignatureTypes,
+            );
             const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
-            expect(mixins.getSignerAddress.callAsync(transactionHash, transaction.signature)).to.be.rejectedWith(
-                RevertReason.SignatureUnsupported,
+            expect(mixins.getSignerAddress(transactionHash, transaction.signature).callAsync()).to.revertWith(
+                new CoordinatorRevertErrors.SignatureError(
+                    CoordinatorRevertErrors.SignatureErrorCodes.Unsupported,
+                    transactionHash,
+                    transaction.signature,
+                ),
+            );
+        });
+        it("should revert with with a signature type that isn't supported", async () => {
+            const data = constants.NULL_BYTES;
+            const transaction = await transactionFactory.newSignedTransactionAsync({ data });
+            transaction.signature = hexUtils.concat(
+                hexUtils.slice(transaction.signature, 0, transaction.signature.length - 1),
+                SignatureType.Wallet,
+            );
+            const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
+            expect(mixins.getSignerAddress(transactionHash, transaction.signature).callAsync()).to.revertWith(
+                new CoordinatorRevertErrors.SignatureError(
+                    CoordinatorRevertErrors.SignatureErrorCodes.Unsupported,
+                    transactionHash,
+                    transaction.signature,
+                ),
             );
         });
     });
 
     describe('decodeOrdersFromFillData', () => {
-        for (const fnName of exchangeConstants.SINGLE_FILL_FN_NAMES) {
+        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 decodedOrders = await mixins.decodeOrdersFromFillData(data).callAsync();
                 const decodedSignedOrders = decodedOrders.map(order => ({
                     ...order,
                     signature: constants.NULL_BYTES,
@@ -154,11 +162,11 @@ describe('Mixins tests', () => {
                 expect(orders).to.deep.eq(decodedSignedOrders);
             });
         }
-        for (const fnName of exchangeConstants.BATCH_FILL_FN_NAMES) {
+        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 decodedOrders = await mixins.decodeOrdersFromFillData(data).callAsync();
                 const decodedSignedOrders = decodedOrders.map(order => ({
                     ...order,
                     signature: constants.NULL_BYTES,
@@ -168,11 +176,11 @@ describe('Mixins tests', () => {
                 expect(orders).to.deep.eq(decodedSignedOrders);
             });
         }
-        for (const fnName of exchangeConstants.MARKET_FILL_FN_NAMES) {
+        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 decodedOrders = await mixins.decodeOrdersFromFillData(data).callAsync();
                 const decodedSignedOrders = decodedOrders.map(order => ({
                     ...order,
                     signature: constants.NULL_BYTES,
@@ -182,22 +190,32 @@ describe('Mixins tests', () => {
                 expect(orders).to.deep.eq(decodedSignedOrders);
             });
         }
-        for (const fnName of [
-            ExchangeFunctionName.CancelOrder,
-            ExchangeFunctionName.BatchCancelOrders,
-            ExchangeFunctionName.CancelOrdersUpTo,
-        ]) {
+        for (const fnName of constants.MATCH_ORDER_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 decodedOrders = await mixins.decodeOrdersFromFillData(data).callAsync();
+                const decodedSignedOrders = decodedOrders.map(order => ({
+                    ...order,
+                    signature: constants.NULL_BYTES,
+                    exchangeAddress: constants.NULL_ADDRESS,
+                    chainId,
+                }));
+                expect(orders).to.deep.eq(decodedSignedOrders);
+            });
+        }
+        for (const fnName of constants.CANCEL_ORDER_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(data).callAsync();
                 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 decodedOrders = await mixins.decodeOrdersFromFillData(data).callAsync();
             const emptyArray: any[] = [];
             expect(emptyArray).to.deep.eq(decodedOrders);
         });
@@ -208,33 +226,24 @@ describe('Mixins tests', () => {
                 new BigNumber(3), // the length of data
                 new BigNumber(4),
             );
-            return expect(mixins.decodeOrdersFromFillData.callAsync(data)).to.revertWith(expectedError);
+            return expect(mixins.decodeOrdersFromFillData(data).callAsync()).to.revertWith(expectedError);
         });
     });
 
     describe('Single order approvals', () => {
-        for (const fnName of exchangeConstants.SINGLE_FILL_FN_NAMES) {
-            it(`Should be successful: function=${fnName}, caller=tx_signer, senderAddress=[verifier], approval_sig=[approver1], expiration=[valid]`, async () => {
+        for (const fnName of constants.SINGLE_FILL_FN_NAMES) {
+            it(`Should be successful: function=${fnName}, caller=tx_signer, senderAddress=[verifier], approval_sig=[approver1]`, async () => {
                 const orders = [defaultOrder];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ 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 },
-                );
+                const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                await mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
+                        approval.signature,
+                    ])
+                    .callAsync({ from: transactionSignerAddress });
             });
-            it(`Should be successful: function=${fnName}, caller=tx_signer, senderAddress=[null], approval_sig=[approver1], expiration=[valid]`, async () => {
+            it(`Should be successful: function=${fnName}, caller=tx_signer, senderAddress=[null], approval_sig=[approver1]`, async () => {
                 const order = {
                     ...defaultOrder,
                     senderAddress: constants.NULL_ADDRESS,
@@ -242,457 +251,257 @@ describe('Mixins tests', () => {
                 const orders = [order];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ 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 },
-                );
+                const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                await mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
+                        approval.signature,
+                    ])
+                    .callAsync({ from: transactionSignerAddress });
             });
-            it(`Should be successful: function=${fnName}, caller=approver1, senderAddress=[verifier], approval_sig=[], expiration=[]`, async () => {
+            it(`Should be successful: function=${fnName}, caller=approver1, senderAddress=[verifier], approval_sig=[]`, async () => {
                 const orders = [defaultOrder];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-                await mixins.assertValidCoordinatorApprovals.callAsync(
-                    transaction,
-                    approvalSignerAddress1,
-                    transaction.signature,
-                    [],
-                    [],
-                    {
+                await mixins
+                    .assertValidCoordinatorApprovals(transaction, approvalSignerAddress1, transaction.signature, [])
+                    .callAsync({
                         from: approvalSignerAddress1,
-                    },
-                );
+                    });
             });
-            it(`Should be successful: function=${fnName}, caller=approver1, senderAddress=[verifier], approval_sig=[approver1], expiration=[invalid]`, async () => {
+            it(`Should be successful: function=${fnName}, caller=approver1, senderAddress=[verifier], approval_sig=[approver1]`, async () => {
                 const orders = [defaultOrder];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ 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 },
-                );
+                const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                await mixins
+                    .assertValidCoordinatorApprovals(transaction, approvalSignerAddress1, transaction.signature, [
+                        approval.signature,
+                    ])
+                    .callAsync({ from: approvalSignerAddress1 });
             });
-            it(`Should be successful: function=${fnName}, caller=approver1, senderAddress=[verifier], approval_sig=[], expiration=[]`, async () => {
+            it(`Should be successful: function=${fnName}, caller=approver1, senderAddress=[verifier], approval_sig=[]`, async () => {
                 const orders = [defaultOrder];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-                await mixins.assertValidCoordinatorApprovals.callAsync(
-                    transaction,
-                    approvalSignerAddress1,
-                    transaction.signature,
-                    [],
-                    [],
-                    {
+                await mixins
+                    .assertValidCoordinatorApprovals(transaction, approvalSignerAddress1, transaction.signature, [])
+                    .callAsync({
                         from: approvalSignerAddress1,
-                    },
-                );
+                    });
             });
-            it(`Should revert: function=${fnName}, caller=tx_signer, senderAddress=[verifier], approval_sig=[invalid], expiration=[valid]`, async () => {
+            it(`Should revert: function=${fnName}, caller=tx_signer, senderAddress=[verifier], approval_sig=[invalid]`, async () => {
                 const orders = [defaultOrder];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-                const currentTimestamp = await getLatestBlockTimestampAsync();
-                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
-                const approval = approvalFactory1.newSignedApproval(
-                    transaction,
-                    transactionSignerAddress,
-                    approvalExpirationTimeSeconds,
+                const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                const signature = hexUtils.concat(
+                    hexUtils.slice(approval.signature, 0, 2),
+                    '0xFFFFFFFF',
+                    hexUtils.slice(approval.signature, 6),
                 );
-                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,
+                const tx = mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
+                        signature,
+                    ])
+                    .callAsync({ from: transactionSignerAddress });
+
+                const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
+                expect(tx).to.revertWith(
+                    new CoordinatorRevertErrors.InvalidApprovalSignatureError(transactionHash, approvalSignerAddress1),
                 );
             });
-            it(`Should revert: function=${fnName}, caller=tx_signer, senderAddress=[verifier], approval_sig=[approver1], expiration=[invalid]`, async () => {
+            it(`Should revert: function=${fnName}, caller=approver2, senderAddress=[verifier], approval_sig=[approver1]`, async () => {
                 const orders = [defaultOrder];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ 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 = await transactionFactory.newSignedTransactionAsync({ 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,
-                );
+                const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
+
+                const tx = mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
+                        approval.signature,
+                    ])
+                    .callAsync({ from: approvalSignerAddress2 });
+                expect(tx).to.revertWith(new CoordinatorRevertErrors.InvalidOriginError(transactionSignerAddress));
             });
         }
     });
     describe('Batch order approvals', () => {
         for (const fnName of [
-            ...exchangeConstants.BATCH_FILL_FN_NAMES,
-            ...exchangeConstants.MARKET_FILL_FN_NAMES,
-            ExchangeFunctionName.MatchOrders,
+            ...constants.BATCH_FILL_FN_NAMES,
+            ...constants.MARKET_FILL_FN_NAMES,
+            ...constants.MATCH_ORDER_FN_NAMES,
         ]) {
-            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1,approver1], approval_sig=[approver1], expiration=[valid]`, async () => {
+            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1,approver1], approval_sig=[approver1]`, async () => {
                 const orders = [defaultOrder, defaultOrder];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ 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 },
-                );
+                const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                await mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
+                        approval.signature,
+                    ])
+                    .callAsync({ from: transactionSignerAddress });
             });
-            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[null,null], feeRecipient=[approver1,approver1], approval_sig=[approver1], expiration=[valid]`, async () => {
+            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[null,null], feeRecipient=[approver1,approver1], approval_sig=[approver1]`, async () => {
                 const orders = [defaultOrder, defaultOrder].map(order => ({
                     ...order,
                     senderAddress: constants.NULL_ADDRESS,
                 }));
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ 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 },
-                );
+                const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                await mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
+                        approval.signature,
+                    ])
+                    .callAsync({ from: transactionSignerAddress });
             });
-            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[null,null], feeRecipient=[approver1,approver1], approval_sig=[], expiration=[]`, async () => {
+            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[null,null], feeRecipient=[approver1,approver1], approval_sig=[]`, async () => {
                 const orders = [defaultOrder, defaultOrder].map(order => ({
                     ...order,
                     senderAddress: constants.NULL_ADDRESS,
                 }));
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-                await mixins.assertValidCoordinatorApprovals.callAsync(
-                    transaction,
-                    transactionSignerAddress,
-                    transaction.signature,
-                    [],
-                    [],
-                    { from: transactionSignerAddress },
-                );
+                await mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [])
+                    .callAsync({ from: transactionSignerAddress });
             });
-            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[verifier,null], feeRecipient=[approver1,approver1], approval_sig=[approver1], expiration=[valid]`, async () => {
+            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[verifier,null], feeRecipient=[approver1,approver1], approval_sig=[approver1]`, async () => {
                 const orders = [defaultOrder, { ...defaultOrder, senderAddress: constants.NULL_ADDRESS }];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ 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 },
-                );
+                const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                await mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
+                        approval.signature,
+                    ])
+                    .callAsync({ 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 () => {
+            it(`Should be successful: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1,approver2], approval_sig=[approver1,approver2]`, async () => {
                 const orders = [defaultOrder, { ...defaultOrder, feeRecipientAddress: approvalSignerAddress2 }];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ 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 },
-                );
+                const approval1 = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                const approval2 = await approvalFactory2.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                await mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
+                        approval1.signature,
+                        approval2.signature,
+                    ])
+                    .callAsync({ from: transactionSignerAddress });
             });
-            it(`Should be successful: function=${fnName} caller=approver1, senderAddress=[verifier,verifier], feeRecipient=[approver1,approver1], approval_sig=[], expiration=[]`, async () => {
+            it(`Should be successful: function=${fnName} caller=approver1, senderAddress=[verifier,verifier], feeRecipient=[approver1,approver1], approval_sig=[]`, async () => {
                 const orders = [defaultOrder, defaultOrder];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-                await mixins.assertValidCoordinatorApprovals.callAsync(
-                    transaction,
-                    approvalSignerAddress1,
-                    transaction.signature,
-                    [],
-                    [],
-                    { from: approvalSignerAddress1 },
-                );
+                await mixins
+                    .assertValidCoordinatorApprovals(transaction, approvalSignerAddress1, transaction.signature, [])
+                    .callAsync({ from: approvalSignerAddress1 });
             });
-            it(`Should revert: function=${fnName} caller=approver1, senderAddress=[verifier,verifier], feeRecipient=[approver1,approver2], approval_sig=[approver2], expiration=[valid]`, async () => {
+            it(`Should revert: function=${fnName} caller=approver1, senderAddress=[verifier,verifier], feeRecipient=[approver1,approver2], approval_sig=[approver2]`, async () => {
                 const orders = [defaultOrder, { ...defaultOrder, feeRecipientAddress: approvalSignerAddress2 }];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ 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,
-                );
+                const approval2 = await approvalFactory2.newSignedApprovalAsync(transaction, transactionSignerAddress);
+
+                const tx = mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
+                        approval2.signature,
+                    ])
+                    .callAsync({ from: approvalSignerAddress1 });
+                expect(tx).to.revertWith(new CoordinatorRevertErrors.InvalidOriginError(transactionSignerAddress));
             });
-            it(`Should revert: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver1], approval_sig=[], expiration=[]`, async () => {
+            it(`Should revert: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver1], approval_sig=[]`, async () => {
                 const orders = [defaultOrder, defaultOrder];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-                expectContractCallFailedAsync(
-                    mixins.assertValidCoordinatorApprovals.callAsync(
-                        transaction,
-                        transactionSignerAddress,
-                        transaction.signature,
-                        [],
-                        [],
-                        { from: transactionSignerAddress },
-                    ),
-                    RevertReason.InvalidApprovalSignature,
+                const tx = mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [])
+                    .callAsync({ from: transactionSignerAddress });
+
+                const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
+                expect(tx).to.revertWith(
+                    new CoordinatorRevertErrors.InvalidApprovalSignatureError(transactionHash, approvalSignerAddress1),
                 );
             });
-            it(`Should revert: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver1], approval_sig=[invalid], expiration=[valid]`, async () => {
+            it(`Should revert: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver1], approval_sig=[invalid]`, async () => {
                 const orders = [defaultOrder, defaultOrder];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-                const currentTimestamp = await getLatestBlockTimestampAsync();
-                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
-                const approval = approvalFactory1.newSignedApproval(
-                    transaction,
-                    transactionSignerAddress,
-                    approvalExpirationTimeSeconds,
+                const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                const signature = hexUtils.concat(
+                    hexUtils.slice(approval.signature, 0, 2),
+                    '0xFFFFFFFF',
+                    hexUtils.slice(approval.signature, 6),
                 );
-                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,
+                const tx = mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
+                        signature,
+                    ])
+                    .callAsync({ from: transactionSignerAddress });
+
+                const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
+                expect(tx).to.revertWith(
+                    new CoordinatorRevertErrors.InvalidApprovalSignatureError(transactionHash, approvalSignerAddress1),
                 );
             });
-            it(`Should revert: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver2], approval_sig=[valid,invalid], expiration=[valid,valid]`, async () => {
+            it(`Should revert: function=${fnName} caller=tx_signer, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver2], approval_sig=[valid,invalid]`, async () => {
                 const orders = [defaultOrder, { ...defaultOrder, feeRecipientAddress: approvalSignerAddress2 }];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-                const currentTimestamp = await getLatestBlockTimestampAsync();
-                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
-                const approval1 = approvalFactory1.newSignedApproval(
-                    transaction,
-                    transactionSignerAddress,
-                    approvalExpirationTimeSeconds,
+                const approval1 = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                const approval2 = await approvalFactory2.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                const approvalSignature2 = hexUtils.concat(
+                    hexUtils.slice(approval2.signature, 0, 2),
+                    '0xFFFFFFFF',
+                    hexUtils.slice(approval2.signature, 6),
                 );
-                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,
+                const tx = mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
+                        approval1.signature,
+                        approvalSignature2,
+                    ])
+                    .callAsync({ from: transactionSignerAddress });
+
+                const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
+                expect(tx).to.revertWith(
+                    new CoordinatorRevertErrors.InvalidApprovalSignatureError(transactionHash, approvalSignerAddress2),
                 );
             });
-            it(`Should revert: function=${fnName} caller=approver1, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver2], approval_sig=[invalid], expiration=[valid]`, async () => {
+            it(`Should revert: function=${fnName} caller=approver1, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver2], approval_sig=[invalid]`, async () => {
                 const orders = [defaultOrder, { ...defaultOrder, feeRecipientAddress: approvalSignerAddress2 }];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-                const currentTimestamp = await getLatestBlockTimestampAsync();
-                const approvalExpirationTimeSeconds = new BigNumber(currentTimestamp).plus(constants.TIME_BUFFER);
-                const approval2 = approvalFactory2.newSignedApproval(
-                    transaction,
-                    transactionSignerAddress,
-                    approvalExpirationTimeSeconds,
+                const approval2 = await approvalFactory2.newSignedApprovalAsync(transaction, transactionSignerAddress);
+                const approvalSignature2 = hexUtils.concat(
+                    hexUtils.slice(approval2.signature, 0, 2),
+                    '0xFFFFFFFF',
+                    hexUtils.slice(approval2.signature, 6),
                 );
-                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,
+                const tx = mixins
+                    .assertValidCoordinatorApprovals(transaction, approvalSignerAddress1, transaction.signature, [
+                        approvalSignature2,
+                    ])
+                    .callAsync({ from: approvalSignerAddress1 });
+
+                const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
+                expect(tx).to.revertWith(
+                    new CoordinatorRevertErrors.InvalidApprovalSignatureError(transactionHash, approvalSignerAddress2),
                 );
             });
-            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 = await transactionFactory.newSignedTransactionAsync({ 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 = await transactionFactory.newSignedTransactionAsync({ 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 () => {
+            it(`Should revert: function=${fnName} caller=approver2, senderAddress=[verifier,verifier], feeRecipient=[approver1, approver1], approval_sig=[valid]`, async () => {
                 const orders = [defaultOrder, defaultOrder];
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ 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,
-                );
+                const approval1 = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
+
+                const tx = mixins
+                    .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
+                        approval1.signature,
+                    ])
+                    .callAsync({ from: approvalSignerAddress2 });
+                expect(tx).to.revertWith(new CoordinatorRevertErrors.InvalidOriginError(transactionSignerAddress));
             });
         }
     });
@@ -701,39 +510,24 @@ describe('Mixins tests', () => {
             const orders = [defaultOrder];
             const data = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrder, orders);
             const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-            await mixins.assertValidCoordinatorApprovals.callAsync(
-                transaction,
-                transactionSignerAddress,
-                transaction.signature,
-                [],
-                [],
-                { from: transactionSignerAddress },
-            );
+            await mixins
+                .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [])
+                .callAsync({ from: transactionSignerAddress });
         });
         it('should allow the tx signer to call `batchCancelOrders` without approval', async () => {
             const orders = [defaultOrder, defaultOrder];
             const data = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.BatchCancelOrders, orders);
             const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-            await mixins.assertValidCoordinatorApprovals.callAsync(
-                transaction,
-                transactionSignerAddress,
-                transaction.signature,
-                [],
-                [],
-                { from: transactionSignerAddress },
-            );
+            await mixins
+                .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [])
+                .callAsync({ from: transactionSignerAddress });
         });
         it('should allow the tx signer to call `cancelOrdersUpTo` without approval', async () => {
             const data = exchangeDataEncoder.encodeOrdersToExchangeData(ExchangeFunctionName.CancelOrdersUpTo);
             const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-            await mixins.assertValidCoordinatorApprovals.callAsync(
-                transaction,
-                transactionSignerAddress,
-                transaction.signature,
-                [],
-                [],
-                { from: transactionSignerAddress },
-            );
+            await mixins
+                .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [])
+                .callAsync({ from: transactionSignerAddress });
         });
     });
 });

contracts/coordinator/test/utils/coordinator_registry_wrapper.ts

@@ -1,65 +0,0 @@
-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/index.ts

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

contracts/coordinator/test/wrappers.ts

@@ -0,0 +1,19 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+export * from '../test/generated-wrappers/coordinator';
+export * from '../test/generated-wrappers/coordinator_registry';
+export * from '../test/generated-wrappers/i_coordinator_approval_verifier';
+export * from '../test/generated-wrappers/i_coordinator_core';
+export * from '../test/generated-wrappers/i_coordinator_registry_core';
+export * from '../test/generated-wrappers/i_coordinator_signature_validator';
+export * from '../test/generated-wrappers/lib_constants';
+export * from '../test/generated-wrappers/lib_coordinator_approval';
+export * from '../test/generated-wrappers/lib_coordinator_rich_errors';
+export * from '../test/generated-wrappers/lib_e_i_p712_coordinator_domain';
+export * from '../test/generated-wrappers/mixin_coordinator_approval_verifier';
+export * from '../test/generated-wrappers/mixin_coordinator_core';
+export * from '../test/generated-wrappers/mixin_coordinator_registry_core';
+export * from '../test/generated-wrappers/mixin_signature_validator';

contracts/coordinator/truffle-config.js

@@ -84,7 +84,7 @@ module.exports = {
         solc: {
             version: '0.5.9',
             settings: {
-                evmVersion: 'constantinople',
+                evmVersion: 'istanbul',
                 optimizer: {
                     enabled: true,
                     runs: 1000000,

contracts/coordinator/tsconfig.json

@@ -2,6 +2,27 @@
     "extends": "../../tsconfig",
     "compilerOptions": { "outDir": "lib", "rootDir": ".", "resolveJsonModule": true },
     "include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*"],
-    "files": ["generated-artifacts/Coordinator.json", "generated-artifacts/CoordinatorRegistry.json"],
+    "files": [
+        "generated-artifacts/Coordinator.json",
+        "generated-artifacts/CoordinatorRegistry.json",
+        "generated-artifacts/LibConstants.json",
+        "generated-artifacts/LibCoordinatorApproval.json",
+        "generated-artifacts/LibCoordinatorRichErrors.json",
+        "generated-artifacts/LibEIP712CoordinatorDomain.json",
+        "test/generated-artifacts/Coordinator.json",
+        "test/generated-artifacts/CoordinatorRegistry.json",
+        "test/generated-artifacts/ICoordinatorApprovalVerifier.json",
+        "test/generated-artifacts/ICoordinatorCore.json",
+        "test/generated-artifacts/ICoordinatorRegistryCore.json",
+        "test/generated-artifacts/ICoordinatorSignatureValidator.json",
+        "test/generated-artifacts/LibConstants.json",
+        "test/generated-artifacts/LibCoordinatorApproval.json",
+        "test/generated-artifacts/LibCoordinatorRichErrors.json",
+        "test/generated-artifacts/LibEIP712CoordinatorDomain.json",
+        "test/generated-artifacts/MixinCoordinatorApprovalVerifier.json",
+        "test/generated-artifacts/MixinCoordinatorCore.json",
+        "test/generated-artifacts/MixinCoordinatorRegistryCore.json",
+        "test/generated-artifacts/MixinSignatureValidator.json"
+    ],
     "exclude": ["./deploy/solc/solc_bin"]
 }

contracts/coordinator/typedoc-tsconfig.json

@@ -3,5 +3,5 @@
     "compilerOptions": {
         "outDir": "lib"
     },
-    "include": ["./src/**/*"]
+    "include": ["./src/**/*", "./test/**/*"]
 }

contracts/dev-utils/.npmignore

@@ -0,0 +1,10 @@
+# Blacklist all files
+.*
+*
+# Whitelist lib
+!lib/**/*
+# Whitelist Solidity contracts
+!contracts/src/**/*
+# Blacklist tests in lib
+/lib/test/*
+# Package specific ignore

contracts/dev-utils/CHANGELOG.json

@@ -1,4 +1,133 @@
 [
+    {
+        "timestamp": 1579682890,
+        "version": "1.0.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "1.0.3",
+        "changes": [
+            {
+                "note": "Fixed ERC721 duplicate token ID bug",
+                "pr": 2400
+            }
+        ],
+        "timestamp": 1578272714
+    },
+    {
+        "timestamp": 1576540892,
+        "version": "1.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1575931811,
+        "version": "1.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "1.0.0",
+        "changes": [
+            {
+                "note": "Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils",
+                "pr": 2330
+            },
+            {
+                "note": "Add new method getOrderHash() to DevUtils contract",
+                "pr": 2321
+            },
+            {
+                "note": "Add new method getTransactionHash() to DevUtils contract",
+                "pr": 2321
+            },
+            {
+                "note": "Add `encodeStaticCallAssetData` and `decodeStaticCallAssetData` in LibAssetData",
+                "pr": 2034
+            },
+            {
+                "note": "Add `revertIfInvalidAssetData` in LibAssetData",
+                "pr": 2034
+            },
+            {
+                "note": "Use built in selectors instead of hard coded constants",
+                "pr": 2055
+            },
+            {
+                "note": "Compile and export all contracts, artifacts, and wrappers by default",
+                "pr": 2055
+            },
+            {
+                "note": "Add `marketBuy/SellOrdersNoThrow` and `marketBuy/SellOrdersFillOrKill` to `LibTransactionDecoder`.",
+                "pr": 2075
+            },
+            {
+                "note": "`run_mocha` package script runs with `UNLIMITED_CONTRACT_SIZE=true` environment variable.",
+                "pr": 2075
+            }
+        ],
+        "timestamp": 1575296764
+    },
+    {
+        "version": "0.1.0-beta.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ],
+        "timestamp": 1575290197
+    },
+    {
+        "version": "0.1.0-beta.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ],
+        "timestamp": 1574238768
+    },
+    {
+        "version": "0.1.0-beta.2",
+        "changes": [
+            {
+                "note": "Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils",
+                "pr": 2330
+            },
+            {
+                "note": "Add new method getOrderHash() to DevUtils contract",
+                "pr": 2321
+            },
+            {
+                "note": "Add new method getTransactionHash() to DevUtils contract",
+                "pr": 2321
+            }
+        ],
+        "timestamp": 1574030254
+    },
+    {
+        "version": "0.1.0-beta.1",
+        "changes": [
+            {
+                "note": "Add `encodeStaticCallAssetData` and `decodeStaticCallAssetData` in LibAssetData",
+                "pr": 2034
+            },
+            {
+                "note": "Add `revertIfInvalidAssetData` in LibAssetData",
+                "pr": 2034
+            }
+        ],
+        "timestamp": 1573159180
+    },
     {
         "version": "0.1.0-beta.0",
         "changes": [

contracts/dev-utils/CHANGELOG.md

@@ -5,6 +5,53 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v1.0.4 - _January 22, 2020_
+
+    * Dependencies updated
+
+## v1.0.3 - _January 6, 2020_
+
+    * Fixed ERC721 duplicate token ID bug (#2400)
+
+## v1.0.2 - _December 17, 2019_
+
+    * Dependencies updated
+
+## v1.0.1 - _December 9, 2019_
+
+    * Dependencies updated
+
+## v1.0.0 - _December 2, 2019_
+
+    * Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils (#2330)
+    * Add new method getOrderHash() to DevUtils contract (#2321)
+    * Add new method getTransactionHash() to DevUtils contract (#2321)
+    * Add `encodeStaticCallAssetData` and `decodeStaticCallAssetData` in LibAssetData (#2034)
+    * Add `revertIfInvalidAssetData` in LibAssetData (#2034)
+    * Use built in selectors instead of hard coded constants (#2055)
+    * Compile and export all contracts, artifacts, and wrappers by default (#2055)
+    * Add `marketBuy/SellOrdersNoThrow` and `marketBuy/SellOrdersFillOrKill` to `LibTransactionDecoder`. (#2075)
+    * `run_mocha` package script runs with `UNLIMITED_CONTRACT_SIZE=true` environment variable. (#2075)
+
+## v0.1.0-beta.4 - _December 2, 2019_
+
+    * Dependencies updated
+
+## v0.1.0-beta.3 - _November 20, 2019_
+
+    * Dependencies updated
+
+## v0.1.0-beta.2 - _November 17, 2019_
+
+    * Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils (#2330)
+    * Add new method getOrderHash() to DevUtils contract (#2321)
+    * Add new method getTransactionHash() to DevUtils contract (#2321)
+
+## v0.1.0-beta.1 - _November 7, 2019_
+
+    * Add `encodeStaticCallAssetData` and `decodeStaticCallAssetData` in LibAssetData (#2034)
+    * Add `revertIfInvalidAssetData` in LibAssetData (#2034)
+
 ## v0.1.0-beta.0 - _October 3, 2019_
 
     * Use built in selectors instead of hard coded constants (#2055)

contracts/dev-utils/compiler.json

@@ -1,13 +1,13 @@
 {
-    "artifactsDir": "./generated-artifacts",
+    "artifactsDir": "./test/generated-artifacts",
     "contractsDir": "./contracts",
     "useDockerisedSolc": false,
     "isOfflineMode": false,
     "compilerSettings": {
-        "evmVersion": "constantinople",
+        "evmVersion": "istanbul",
         "optimizer": {
             "enabled": true,
-            "runs": 10000,
+            "runs": 5000,
             "details": { "yul": true, "deduplicate": true, "cse": true, "constantOptimizer": true }
         },
         "outputSelection": {

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

@@ -19,22 +19,62 @@
 pragma solidity ^0.5.5;
 pragma experimental ABIEncoderV2;
 
+import "@0x/contracts-exchange-libs/contracts/src/LibEIP712ExchangeDomain.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibZeroExTransaction.sol";
+import "@0x/contracts-utils/contracts/src/LibEIP712.sol";
+import "@0x/contracts-utils/contracts/src/LibBytes.sol";
 import "./OrderValidationUtils.sol";
 import "./OrderTransferSimulationUtils.sol";
-import "./LibTransactionDecoder.sol";
 import "./EthBalanceChecker.sol";
 
 
 // solhint-disable no-empty-blocks
 contract DevUtils is
     OrderValidationUtils,
-    LibTransactionDecoder,
-    EthBalanceChecker,
-    OrderTransferSimulationUtils
+    LibEIP712ExchangeDomain,
+    EthBalanceChecker
 {
-    constructor (address _exchange)
+    constructor (
+        address _exchange,
+        address _chaiBridge
+    )
         public
-        OrderValidationUtils(_exchange)
+        OrderValidationUtils(
+            _exchange,
+            _chaiBridge
+        )
         OrderTransferSimulationUtils(_exchange)
+        LibEIP712ExchangeDomain(uint256(0), address(0)) // null args because because we only use constants
     {}
+
+    function getOrderHash(
+        LibOrder.Order memory order,
+        uint256 chainId,
+        address exchange
+    )
+        public
+        pure
+        returns (bytes32 orderHash)
+    {
+        return LibOrder.getTypedDataHash(
+            order,
+            LibEIP712.hashEIP712Domain(_EIP712_EXCHANGE_DOMAIN_NAME, _EIP712_EXCHANGE_DOMAIN_VERSION, chainId, exchange)
+        );
+    }
+
+    function getTransactionHash(
+        LibZeroExTransaction.ZeroExTransaction memory transaction,
+        uint256 chainId,
+        address exchange
+    )
+        public
+        pure
+        returns (bytes32 transactionHash)
+    {
+        return LibZeroExTransaction.getTypedDataHash(
+            transaction,
+            LibEIP712.hashEIP712Domain(_EIP712_EXCHANGE_DOMAIN_NAME, _EIP712_EXCHANGE_DOMAIN_VERSION, chainId, exchange)
+        );
+    }
 }

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

@@ -26,10 +26,14 @@ import "@0x/contracts-asset-proxy/contracts/src/interfaces/IAssetProxy.sol";
 import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
 import "@0x/contracts-erc721/contracts/src/interfaces/IERC721Token.sol";
 import "@0x/contracts-erc1155/contracts/src/interfaces/IERC1155.sol";
+import "@0x/contracts-asset-proxy/contracts/src/interfaces/IChai.sol";
+import "@0x/contracts-utils/contracts/src/DeploymentConstants.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibMath.sol";
 
 
-contract LibAssetData {
-
+contract LibAssetData is
+    DeploymentConstants
+{
     // 2^256 - 1
     uint256 constant internal _MAX_UINT256 = uint256(-1);
 
@@ -41,9 +45,13 @@ contract LibAssetData {
     address internal _ERC721_PROXY_ADDRESS;
     address internal _ERC1155_PROXY_ADDRESS;
     address internal _STATIC_CALL_PROXY_ADDRESS;
+    address internal _CHAI_BRIDGE_ADDRESS;
     // solhint-enable var-name-mixedcase
 
-    constructor (address _exchange)
+    constructor (
+        address _exchange,
+        address _chaiBridge
+    )
         public
     {
         _EXCHANGE = IExchange(_exchange);
@@ -51,6 +59,7 @@ contract LibAssetData {
         _ERC721_PROXY_ADDRESS = _EXCHANGE.getAssetProxy(IAssetData(address(0)).ERC721Token.selector);
         _ERC1155_PROXY_ADDRESS = _EXCHANGE.getAssetProxy(IAssetData(address(0)).ERC1155Assets.selector);
         _STATIC_CALL_PROXY_ADDRESS = _EXCHANGE.getAssetProxy(IAssetData(address(0)).StaticCall.selector);
+        _CHAI_BRIDGE_ADDRESS = _chaiBridge;
     }
 
     /// @dev Returns the owner's balance of the assets(s) specified in
@@ -62,7 +71,6 @@ contract LibAssetData {
     /// @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
@@ -71,16 +79,8 @@ contract LibAssetData {
         if (assetProxyId == IAssetData(address(0)).ERC20Token.selector) {
             // Get ERC20 token address
             address tokenAddress = assetData.readAddress(16);
+            balance = _erc20BalanceOf(tokenAddress, ownerAddress);
 
-            // Encode data for `balanceOf(ownerAddress)`
-            bytes memory balanceOfData = abi.encodeWithSelector(
-                IERC20Token(address(0)).balanceOf.selector,
-                ownerAddress
-            );
-
-            // Query balance
-            (bool success, bytes memory returnData) = tokenAddress.staticcall(balanceOfData);
-            balance = success && returnData.length == 32 ? returnData.readUint256(0) : 0;
         } else if (assetProxyId == IAssetData(address(0)).ERC721Token.selector) {
             // Get ERC721 token address and id
             (, address tokenAddress, uint256 tokenId) = decodeERC721AssetData(assetData);
@@ -94,12 +94,18 @@ contract LibAssetData {
             (bool success, bytes memory returnData) = tokenAddress.staticcall(ownerOfCalldata);
             address currentOwnerAddress = (success && returnData.length == 32) ? returnData.readAddress(12) : address(0);
             balance = currentOwnerAddress == ownerAddress ? 1 : 0;
+
         } else if (assetProxyId == IAssetData(address(0)).ERC1155Assets.selector) {
             // 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++) {
+                // Skip over the token if the corresponding value is 0.
+                if (tokenValues[i] == 0) {
+                    continue;
+                }
+
                 // Encode data for `balanceOf(ownerAddress, tokenIds[i])
                 bytes memory balanceOfData = abi.encodeWithSelector(
                     IERC1155(address(0)).balanceOf.selector,
@@ -113,10 +119,14 @@ contract LibAssetData {
 
                 // Scale total balance down by corresponding value in assetData
                 uint256 scaledBalance = totalBalance / tokenValues[i];
+                if (scaledBalance == 0) {
+                    return 0;
+                }
                 if (scaledBalance < balance || balance == 0) {
                     balance = scaledBalance;
                 }
             }
+
         } else if (assetProxyId == IAssetData(address(0)).StaticCall.selector) {
             // Encode data for `staticCallProxy.transferFrom(assetData,...)`
             bytes memory transferFromData = abi.encodeWithSelector(
@@ -132,22 +142,41 @@ contract LibAssetData {
 
             // Success means that the staticcall can be made an unlimited amount of times
             balance = success ? _MAX_UINT256 : 0;
+
+        } else if (assetProxyId == IAssetData(address(0)).ERC20Bridge.selector) {
+            // Get address of ERC20 token and bridge contract
+            (, address tokenAddress, address bridgeAddress,) = decodeERC20BridgeAssetData(assetData);
+            if (tokenAddress == _getDaiAddress() && bridgeAddress == _CHAI_BRIDGE_ADDRESS) {
+                uint256 chaiBalance = _erc20BalanceOf(_getChaiAddress(), ownerAddress);
+                // Calculate Dai balance
+                balance = _convertChaiToDaiAmount(chaiBalance);
+            }
+            // Balance will be 0 if bridge is not supported
+
         } else if (assetProxyId == IAssetData(address(0)).MultiAsset.selector) {
             // 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++) {
+                // Skip over the asset if the corresponding amount is 0.
+                if (assetAmounts[i] == 0) {
+                    continue;
+                }
+
                 // 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 == 0) {
+                    return 0;
+                }
                 if (scaledBalance < balance || balance == 0) {
                     balance = scaledBalance;
                 }
             }
-        } 
+        }
 
         // Balance will be 0 if assetProxyId is unknown
         return balance;
@@ -160,7 +189,6 @@ contract LibAssetData {
     /// 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;
@@ -181,7 +209,6 @@ contract LibAssetData {
     /// @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
@@ -193,11 +220,19 @@ contract LibAssetData {
 
             uint256 length = nestedAssetData.length;
             for (uint256 i = 0; i != length; i++) {
+                // Skip over the asset if the corresponding amount is 0.
+                if (amounts[i] == 0) {
+                    continue;
+                }
+
                 // 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 == 0) {
+                    return 0;
+                }
                 if (scaledAllowance < allowance || allowance == 0) {
                     allowance = scaledAllowance;
                 }
@@ -219,6 +254,7 @@ contract LibAssetData {
             // Query allowance
             (bool success, bytes memory returnData) = tokenAddress.staticcall(allowanceData);
             allowance = success && returnData.length == 32 ? returnData.readUint256(0) : 0;
+
         } else if (assetProxyId == IAssetData(address(0)).ERC721Token.selector) {
             // Get ERC721 token address and id
             (, address tokenAddress, uint256 tokenId) = decodeERC721AssetData(assetData);
@@ -244,6 +280,7 @@ contract LibAssetData {
                 // Allowance is 2^256 - 1 if `isApprovedForAll` returned true
                 allowance = _MAX_UINT256;
             }
+
         } else if (assetProxyId == IAssetData(address(0)).ERC1155Assets.selector) {
             // Get ERC1155 token address
             (, address tokenAddress, , , ) = decodeERC1155AssetData(assetData);
@@ -258,9 +295,26 @@ contract LibAssetData {
             // 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 == IAssetData(address(0)).StaticCall.selector) {
             // The StaticCallProxy does not require any approvals
             allowance = _MAX_UINT256;
+
+        } else if (assetProxyId == IAssetData(address(0)).ERC20Bridge.selector) {
+            // Get address of ERC20 token and bridge contract
+            (, address tokenAddress, address bridgeAddress,) = decodeERC20BridgeAssetData(assetData);
+            if (tokenAddress == _getDaiAddress() && bridgeAddress == _CHAI_BRIDGE_ADDRESS) {
+                bytes memory allowanceData = abi.encodeWithSelector(
+                    IERC20Token(address(0)).allowance.selector,
+                    ownerAddress,
+                    _CHAI_BRIDGE_ADDRESS
+                );
+                (bool success, bytes memory returnData) = _getChaiAddress().staticcall(allowanceData);
+                uint256 chaiAllowance = success && returnData.length == 32 ? returnData.readUint256(0) : 0;
+                // Dai allowance is unlimited if Chai allowance is unlimited
+                allowance = chaiAllowance == _MAX_UINT256 ? _MAX_UINT256 : _convertChaiToDaiAmount(chaiAllowance);
+            }
+            // Allowance will be 0 if bridge is not supported
         }
 
         // Allowance will be 0 if the assetProxyId is unknown
@@ -274,7 +328,6 @@ contract LibAssetData {
     /// 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;
@@ -292,7 +345,6 @@ contract LibAssetData {
     /// 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);
@@ -308,7 +360,6 @@ contract LibAssetData {
     /// 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);
@@ -316,6 +367,29 @@ contract LibAssetData {
         return (balances, allowances);
     }
 
+    /// @dev Decode AssetProxy identifier
+    /// @param assetData AssetProxy-compliant asset data describing an ERC-20, ERC-721, ERC1155, or MultiAsset asset.
+    /// @return The AssetProxy identifier
+    function decodeAssetProxyId(bytes memory assetData)
+        public
+        pure
+        returns (
+            bytes4 assetProxyId
+        )
+    {
+        assetProxyId = assetData.readBytes4(0);
+
+        require(
+            assetProxyId == IAssetData(address(0)).ERC20Token.selector ||
+            assetProxyId == IAssetData(address(0)).ERC721Token.selector ||
+            assetProxyId == IAssetData(address(0)).ERC1155Assets.selector ||
+            assetProxyId == IAssetData(address(0)).MultiAsset.selector ||
+            assetProxyId == IAssetData(address(0)).StaticCall.selector,
+            "WRONG_PROXY_ID"
+        );
+        return assetProxyId;
+    }
+
     /// @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.
@@ -330,7 +404,7 @@ contract LibAssetData {
 
     /// @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 
+    /// @return The AssetProxy identifier, and the address of the ERC-20
     /// contract hosting this asset.
     function decodeERC20AssetData(bytes memory assetData)
         public
@@ -515,4 +589,146 @@ contract LibAssetData {
         );
         // solhint-enable indent
     }
+
+    /// @dev Encode StaticCall asset data into the format described in the AssetProxy contract specification.
+    /// @param staticCallTargetAddress Target address of StaticCall.
+    /// @param staticCallData Data that will be passed to staticCallTargetAddress in the StaticCall.
+    /// @param expectedReturnDataHash Expected Keccak-256 hash of the StaticCall return data.
+    /// @return AssetProxy-compliant asset data describing the set of assets.
+    function encodeStaticCallAssetData(
+        address staticCallTargetAddress,
+        bytes memory staticCallData,
+        bytes32 expectedReturnDataHash
+    )
+        public
+        pure
+        returns (bytes memory assetData)
+    {
+        assetData = abi.encodeWithSelector(
+            IAssetData(address(0)).StaticCall.selector,
+            staticCallTargetAddress,
+            staticCallData,
+            expectedReturnDataHash
+        );
+        return assetData;
+    }
+
+    /// @dev Decode StaticCall asset data from the format described in the AssetProxy contract specification.
+    /// @param assetData AssetProxy-compliant asset data describing a StaticCall asset
+    /// @return The StaticCall AssetProxy identifier, the target address of the StaticCAll, the data to be
+    /// passed to the target address, and the expected Keccak-256 hash of the static call return data.
+    function decodeStaticCallAssetData(bytes memory assetData)
+        public
+        pure
+        returns (
+            bytes4 assetProxyId,
+            address staticCallTargetAddress,
+            bytes memory staticCallData,
+            bytes32 expectedReturnDataHash
+        )
+    {
+        assetProxyId = assetData.readBytes4(0);
+
+        require(
+            assetProxyId == IAssetData(address(0)).StaticCall.selector,
+            "WRONG_PROXY_ID"
+        );
+
+        (staticCallTargetAddress, staticCallData, expectedReturnDataHash) = abi.decode(
+            assetData.slice(4, assetData.length),
+            (address, bytes, bytes32)
+        );
+    }
+
+    /// @dev Decode ERC20Bridge asset data from the format described in the AssetProxy contract specification.
+    /// @param assetData AssetProxy-compliant asset data describing an ERC20Bridge asset
+    /// @return The ERC20BridgeProxy identifier, the address of the ERC20 token to transfer, the address
+    /// of the bridge contract, and extra data to be passed to the bridge contract.
+    function decodeERC20BridgeAssetData(bytes memory assetData)
+        public
+        pure
+        returns (
+            bytes4 assetProxyId,
+            address tokenAddress,
+            address bridgeAddress,
+            bytes memory bridgeData
+        )
+    {
+        assetProxyId = assetData.readBytes4(0);
+
+        require(
+            assetProxyId == IAssetData(address(0)).ERC20Bridge.selector,
+            "WRONG_PROXY_ID"
+        );
+
+        (tokenAddress, bridgeAddress, bridgeData) = abi.decode(
+            assetData.slice(4, assetData.length),
+            (address, address, bytes)
+        );
+    }
+
+    /// @dev Reverts if assetData is not of a valid format for its given proxy id.
+    /// @param assetData AssetProxy compliant asset data.
+    function revertIfInvalidAssetData(bytes memory assetData)
+        public
+        pure
+    {
+        bytes4 assetProxyId = assetData.readBytes4(0);
+
+        if (assetProxyId == IAssetData(address(0)).ERC20Token.selector) {
+            decodeERC20AssetData(assetData);
+        } else if (assetProxyId == IAssetData(address(0)).ERC721Token.selector) {
+            decodeERC721AssetData(assetData);
+        } else if (assetProxyId == IAssetData(address(0)).ERC1155Assets.selector) {
+            decodeERC1155AssetData(assetData);
+        } else if (assetProxyId == IAssetData(address(0)).MultiAsset.selector) {
+            decodeMultiAssetData(assetData);
+        } else if (assetProxyId == IAssetData(address(0)).StaticCall.selector) {
+            decodeStaticCallAssetData(assetData);
+        } else if (assetProxyId == IAssetData(address(0)).ERC20Bridge.selector) {
+            decodeERC20BridgeAssetData(assetData);
+        } else {
+            revert("WRONG_PROXY_ID");
+        }
+    }
+
+    /// @dev Queries balance of an ERC20 token. Returns 0 if call was unsuccessful.
+    /// @param tokenAddress Address of ERC20 token.
+    /// @param ownerAddress Address of owner of ERC20 token.
+    /// @return balance ERC20 token balance of owner.
+    function _erc20BalanceOf(
+        address tokenAddress,
+        address ownerAddress
+    )
+        internal
+        view
+        returns (uint256 balance)
+    {
+        // Encode data for `balanceOf(ownerAddress)`
+        bytes memory balanceOfData = abi.encodeWithSelector(
+            IERC20Token(address(0)).balanceOf.selector,
+            ownerAddress
+        );
+
+        // Query balance
+        (bool success, bytes memory returnData) = tokenAddress.staticcall(balanceOfData);
+        balance = success && returnData.length == 32 ? returnData.readUint256(0) : 0;
+        return balance;
+    }
+
+    /// @dev Converts an amount of Chai into its equivalent Dai amount.
+    ///      Also accumulates Dai from DSR if called after the last time it was collected.
+    /// @param chaiAmount Amount of Chai to converts.
+    function _convertChaiToDaiAmount(uint256 chaiAmount)
+        internal
+        returns (uint256 daiAmount)
+    {
+        PotLike pot = IChai(_getChaiAddress()).pot();
+        // Accumulate savings if called after last time savings were collected
+        uint256 chiMultiplier = (now > pot.rho())
+            ? pot.drip()
+            : pot.chi();
+        daiAmount = LibMath.getPartialAmountFloor(chiMultiplier, 10**27, chaiAmount);
+        return daiAmount;
+    }
 }

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

@@ -41,6 +41,10 @@ contract OrderTransferSimulationUtils is
         TransfersSuccessful       // All transfers in the order were successful
     }
 
+    // NOTE(jalextowle): This is a random address that we use to avoid issues that addresses like `address(1)`
+    // may cause later.
+    address constant internal UNUSED_ADDRESS = address(0x377f698C4c287018D09b516F415317aEC5919332);
+
     // keccak256(abi.encodeWithSignature("Error(string)", "TRANSFERS_SUCCESSFUL"));
     bytes32 constant internal _TRANSFERS_SUCCESSFUL_RESULT_HASH = 0xf43f26ea5a94b478394a975e856464913dc1a8a1ca70939d974aa7c238aa0ce0;
 
@@ -54,6 +58,51 @@ contract OrderTransferSimulationUtils is
         _EXCHANGE = IExchange(_exchange);
     }
 
+    /// @dev Simulates the maker transfers within an order and returns the index of the first failed transfer.
+    /// @param order The order to simulate transfers for.
+    /// @param takerAddress The address of the taker that will fill the order.
+    /// @param takerAssetFillAmount The amount of takerAsset that the taker wished to fill.
+    /// @return The index of the first failed transfer (or 4 if all transfers are successful).
+    function getSimulatedOrderMakerTransferResults(
+        LibOrder.Order memory order,
+        address takerAddress,
+        uint256 takerAssetFillAmount
+    )
+        public
+        returns (OrderTransferResults orderTransferResults)
+    {
+        LibFillResults.FillResults memory fillResults = LibFillResults.calculateFillResults(
+            order,
+            takerAssetFillAmount,
+            _EXCHANGE.protocolFeeMultiplier(),
+            tx.gasprice
+        );
+
+        bytes[] memory assetData = new bytes[](2);
+        address[] memory fromAddresses = new address[](2);
+        address[] memory toAddresses = new address[](2);
+        uint256[] memory amounts = new uint256[](2);
+
+        // Transfer `makerAsset` from maker to taker
+        assetData[0] = order.makerAssetData;
+        fromAddresses[0] = order.makerAddress;
+        toAddresses[0] = takerAddress == address(0) ? UNUSED_ADDRESS : takerAddress;
+        amounts[0] = fillResults.makerAssetFilledAmount;
+
+        // Transfer `makerFeeAsset` from maker to feeRecipient
+        assetData[1] = order.makerFeeAssetData;
+        fromAddresses[1] = order.makerAddress;
+        toAddresses[1] = order.feeRecipientAddress == address(0) ? UNUSED_ADDRESS : order.feeRecipientAddress;
+        amounts[1] = fillResults.makerFeePaid;
+
+        return _simulateTransferFromCalls(
+            assetData,
+            fromAddresses,
+            toAddresses,
+            amounts
+        );
+    }
+
     /// @dev Simulates all of the transfers within an order and returns the index of the first failed transfer.
     /// @param order The order to simulate transfers for.
     /// @param takerAddress The address of the taker that will fill the order.
@@ -89,21 +138,69 @@ contract OrderTransferSimulationUtils is
         // Transfer `makerAsset` from maker to taker
         assetData[1] = order.makerAssetData;
         fromAddresses[1] = order.makerAddress;
-        toAddresses[1] = takerAddress;
+        toAddresses[1] = takerAddress == address(0) ? UNUSED_ADDRESS : takerAddress;
         amounts[1] = fillResults.makerAssetFilledAmount;
 
         // Transfer `takerFeeAsset` from taker to feeRecipient
         assetData[2] = order.takerFeeAssetData;
         fromAddresses[2] = takerAddress;
-        toAddresses[2] = order.feeRecipientAddress;
+        toAddresses[2] = order.feeRecipientAddress == address(0) ? UNUSED_ADDRESS : order.feeRecipientAddress;
         amounts[2] = fillResults.takerFeePaid;
 
         // Transfer `makerFeeAsset` from maker to feeRecipient
         assetData[3] = order.makerFeeAssetData;
         fromAddresses[3] = order.makerAddress;
-        toAddresses[3] = order.feeRecipientAddress;
+        toAddresses[3] = order.feeRecipientAddress == address(0) ? UNUSED_ADDRESS : order.feeRecipientAddress;
         amounts[3] = fillResults.makerFeePaid;
 
+        return _simulateTransferFromCalls(
+            assetData,
+            fromAddresses,
+            toAddresses,
+            amounts
+        );
+    }
+
+    /// @dev Simulates all of the transfers for each given order and returns the indices of each first failed transfer.
+    /// @param orders Array of orders to individually simulate transfers for.
+    /// @param takerAddresses Array of addresses of takers that will fill each order.
+    /// @param takerAssetFillAmounts Array of amounts of takerAsset that will be filled for each order.
+    /// @return The indices of the first failed transfer (or 4 if all transfers are successful) for each order.
+    function getSimulatedOrdersTransferResults(
+        LibOrder.Order[] memory orders,
+        address[] memory takerAddresses,
+        uint256[] memory takerAssetFillAmounts
+    )
+        public
+        returns (OrderTransferResults[] memory orderTransferResults)
+    {
+        uint256 length = orders.length;
+        orderTransferResults = new OrderTransferResults[](length);
+        for (uint256 i = 0; i != length; i++) {
+            orderTransferResults[i] = getSimulatedOrderTransferResults(
+                orders[i],
+                takerAddresses[i],
+                takerAssetFillAmounts[i]
+            );
+        }
+        return orderTransferResults;
+    }
+
+    /// @dev Makes the simulation call with information about the transfers and processes
+    ///      the returndata.
+    /// @param assetData The assetdata to use to make transfers.
+    /// @param fromAddresses The addresses to transfer funds.
+    /// @param toAddresses The addresses that will receive funds
+    /// @param amounts The amounts involved in the transfer.
+    function _simulateTransferFromCalls(
+        bytes[] memory assetData,
+        address[] memory fromAddresses,
+        address[] memory toAddresses,
+        uint256[] memory amounts
+    )
+        internal
+        returns (OrderTransferResults orderTransferResults)
+    {
         // Encode data for `simulateDispatchTransferFromCalls(assetData, fromAddresses, toAddresses, amounts)`
         bytes memory simulateDispatchTransferFromCallsData = abi.encodeWithSelector(
             IExchange(address(0)).simulateDispatchTransferFromCalls.selector,
@@ -132,29 +229,4 @@ contract OrderTransferSimulationUtils is
             revert("UNKNOWN_RETURN_DATA");
         }
     }
-
-    /// @dev Simulates all of the transfers for each given order and returns the indices of each first failed transfer.
-    /// @param orders Array of orders to individually simulate transfers for.
-    /// @param takerAddresses Array of addresses of takers that will fill each order.
-    /// @param takerAssetFillAmounts Array of amounts of takerAsset that will be filled for each order.
-    /// @return The indices of the first failed transfer (or 4 if all transfers are successful) for each order.
-    function getSimulatedOrdersTransferResults(
-        LibOrder.Order[] memory orders,
-        address[] memory takerAddresses,
-        uint256[] memory takerAssetFillAmounts
-    )
-        public
-        returns (OrderTransferResults[] memory orderTransferResults)
-    {
-        uint256 length = orders.length;
-        orderTransferResults = new OrderTransferResults[](length);
-        for (uint256 i = 0; i != length; i++) {
-            orderTransferResults[i] = getSimulatedOrderTransferResults(
-                orders[i],
-                takerAddresses[i],
-                takerAssetFillAmounts[i]
-            );
-        }
-        return orderTransferResults;
-    }
 }