Publish

- @0x/contracts-asset-proxy@2.2.5
 - @0x/contracts-coordinator@2.0.10
 - @0x/contracts-dev-utils@0.0.7
 - @0x/contracts-erc1155@1.1.12
 - @0x/contracts-erc20@2.2.11
 - @0x/contracts-erc721@2.1.12
 - @0x/contracts-exchange-forwarder@3.0.9
 - @0x/contracts-exchange-libs@3.0.5
 - @0x/contracts-exchange@2.1.11
 - @0x/contracts-extensions@4.0.5
 - @0x/contracts-multisig@3.1.11
 - @0x/contracts-test-utils@3.1.13
 - @0x/contracts-utils@3.2.1
 - 0x.js@6.0.15
 - @0x/abi-gen-templates@2.4.1
 - @0x/abi-gen-wrappers@5.2.0
 - @0x/abi-gen@4.1.0
 - @0x/assert@2.1.3
 - @0x/asset-buyer@6.1.11
 - @0x/asset-swapper@1.0.1
 - @0x/base-contract@5.3.1
 - @0x/connect@5.0.16
 - @0x/contract-addresses@3.0.3
 - @0x/contract-artifacts@2.0.4
 - @0x/contract-wrappers@11.0.0
 - @0x/contracts-gen@1.0.13
 - @0x/dev-utils@2.3.0
 - @0x/fill-scenarios@3.0.16
 - @0x/instant@1.0.28
 - @0x/json-schemas@3.1.13
 - @0x/migrations@4.2.0
 - @0x/monorepo-scripts@1.0.34
 - @0x/order-utils@8.2.5
 - @0x/order-watcher@4.0.17
 - @0x/python-contract-wrappers@1.0.3
 - @0x/sol-compiler@3.1.12
 - @0x/sol-coverage@3.0.9
 - @0x/sol-doc@2.0.16
 - @0x/sol-profiler@3.1.11
 - @0x/sol-trace@2.0.17
 - @0x/sol-tracing-utils@6.0.16
 - @0x/sra-spec@2.0.14
 - @0x/subproviders@5.0.1
 - @0x/testnet-faucets@1.0.84
 - @0x/utils@4.5.0
 - @0x/web3-wrapper@6.0.10
 - @0x/website@0.0.87

.circleci/config.yml

@@ -33,6 +33,12 @@ jobs:
                   key: python-contract-wrappers-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
                       - ~/repo/packages/python-contract-wrappers/generated
+            - store_artifacts:
+                  path: ~/repo/packages/python-contract-wrappers/generated
+            - store_artifacts:
+                  path: ~/repo/packages/abi-gen/test-cli/output
+            - store_artifacts:
+                  path: ~/repo/packages/abi-gen-wrappers/generated_docs
     build-website:
         resource_class: medium+
         docker:
@@ -102,7 +108,6 @@ jobs:
             - run: yarn wsrun test:circleci @0x/contract-wrappers
             - run: yarn wsrun test:circleci @0x/dev-utils
             - run: yarn wsrun test:circleci @0x/json-schemas
-            - run: yarn wsrun test:circleci @0x/metacoin
             - run: yarn wsrun test:circleci @0x/order-utils
             - run: yarn wsrun test:circleci @0x/order-watcher
             - run: yarn wsrun test:circleci @0x/sol-compiler
@@ -144,10 +149,6 @@ jobs:
                   key: coverage-json-schemas-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
                       - ~/repo/packages/json-schemas/coverage/lcov.info
-            - save_cache:
-                  key: coverage-metacoin-{{ .Environment.CIRCLE_SHA1 }}
-                  paths:
-                      - ~/repo/packages/metacoin/coverage/lcov.info
             - save_cache:
                   key: coverage-order-utils-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
@@ -181,12 +182,13 @@ jobs:
         docker:
             - image: circleci/python
             - image: 0xorg/ganache-cli:2.2.2
-            - image: 0xorg/launch-kit-ci
+            - image: 0xorg/launch-kit-backend:74bcc39
               environment:
                   RPC_URL: http://localhost:8545
                   NETWORK_ID: 50
                   WHITELIST_ALL_TOKENS: True
-              command: bash -c "until curl -sfd'{\"method\":\"net_listening\"}' http://localhost:8545 | grep true; do continue; done; forever ts/lib/index.js"
+              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"
         steps:
             - checkout
             - run: sudo chown -R circleci:circleci /usr/local/bin
@@ -209,7 +211,8 @@ jobs:
             - run:
                   command: |
                       cd python-packages
-                      ./cmd_pkgs_in_dep_order.py coverage run setup.py test
+                      ./parallel_without_sra_client coverage run setup.py test
+                      ./build_docs
             - save_cache:
                   key: coverage-python-contract-addresses-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
@@ -234,6 +237,24 @@ jobs:
                   key: coverage-python-sra-client-{{ .Environment.CIRCLE_SHA1 }}
                   paths:
                       - ~/repo/python-packages/sra_client/.coverage
+            - store_artifacts:
+                  path: ~/repo/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc20_token/__init__.py
+            - store_artifacts:
+                  path: ~/repo/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/exchange/__init__.py
+            - store_artifacts:
+                  path: ~/repo/python-packages/contract_addresses/build
+            - store_artifacts:
+                  path: ~/repo/python-packages/contract_artifacts/build
+            - store_artifacts:
+                  path: ~/repo/python-packages/contract_wrappers/build
+            - store_artifacts:
+                  path: ~/repo/python-packages/json_schemas/build
+            - store_artifacts:
+                  path: ~/repo/python-packages/middlewares/build
+            - store_artifacts:
+                  path: ~/repo/python-packages/order_utils/build
+            - store_artifacts:
+                  path: ~/repo/python-packages/sra_client/build
     test-rest-python:
         working_directory: ~/repo
         docker:
@@ -326,9 +347,6 @@ jobs:
             - restore_cache:
                   keys:
                       - coverage-json-schemas-{{ .Environment.CIRCLE_SHA1 }}
-            - restore_cache:
-                  keys:
-                      - coverage-metacoin-{{ .Environment.CIRCLE_SHA1 }}
             - restore_cache:
                   keys:
                       - coverage-order-utils-{{ .Environment.CIRCLE_SHA1 }}

.gitattributes

@@ -3,5 +3,6 @@
 # Automatically collapse generated files in GitHub.
 *.svg linguist-generated=true
 packages/contract-artifacts/artifacts/*json linguist-generated=true
-packages/abi-gen-wrappers/src/generated-wrappers/*.ts liguist-generated=true
+packages/abi-gen-wrappers/src/generated-wrappers/*.ts linguist-generated=true
+packages/contract-wrappers/src/generated-wrappers/*.ts linguist-generated=true
 

.github/autolabeler.yml

@@ -22,15 +22,12 @@ contracts: ['contracts']
 @0x/tslint-config: ['packages/tslint-config']
 @0x/asset-buyer: ['packages/asset-buyer']
 @0x/order-watcher: ['packages/order-watcher']
-@0x/react-docs: ['packages/react-docs']
 @0x/order-utils: ['packages/order-utils']
-@0x/react-shared: ['packages/react-shared']
 @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/metacoin: ['packages/metacoin']
 @0x/contract-artifacts: ['packages/contract-artifacts']
 @0x/dev-utils: ['packages/dev-utils']
 @0x/contract-wrappers: ['packages/contract-wrappers']

.gitignore

@@ -77,7 +77,6 @@ TODO.md
 
 packages/website/public/bundle*
 packages/dev-tools-pages/public/bundle*
-packages/react-docs/example/public/bundle*
 
 # server cli
 packages/testnet-faucets/server/
@@ -96,7 +95,6 @@ contracts/extensions/generated-artifacts/
 contracts/exchange-forwarder/generated-artifacts/
 contracts/dev-utils/generated-artifacts/
 packages/sol-tracing-utils/test/fixtures/artifacts/
-packages/metacoin/artifacts/
 python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/
 
 # generated contract wrappers
@@ -114,7 +112,26 @@ contracts/erc1155/generated-wrappers/
 contracts/extensions/generated-wrappers/
 contracts/exchange-forwarder/generated-wrappers/
 contracts/dev-utils/generated-wrappers/
-packages/metacoin/src/contract_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
 
 # cli test output
 packages/abi-gen/test-cli/output
@@ -134,3 +151,6 @@ python-packages/*/dist
 __pycache__
 python-packages/*/src/*.egg-info
 python-packages/*/.coverage
+
+# python keeps package-local copies of json schemas
+python-packages/json_schemas/src/zero_ex/json_schemas/schemas

.prettierignore

@@ -27,8 +27,6 @@ lib
 /packages/abi-gen/test-cli/output
 /packages/json-schemas/schemas
 /python-packages/json_schemas/src/zero_ex/json_schemas/schemas
-/packages/metacoin/src/contract_wrappers
-/packages/metacoin/artifacts
 /packages/sra-spec/public/
 /packages/dev-tools-pages/ts/**/data.json
 package.json
@@ -37,3 +35,6 @@ packages/sol-coverage/test/fixtures/artifacts
 .pytest_cache
 .mypy_cache
 .tox
+packages/abi-gen/test-cli/fixtures/artifacts/AbiGenDummy.json
+packages/abi-gen/test-cli/fixtures/artifacts/LibDummy.json
+packages/abi-gen/test-cli/fixtures/artifacts/TestLibDummy.json

CODEOWNERS

@@ -20,7 +20,6 @@ packages/contract-artifacts/ @albrow
 packages/dev-utils/ @LogvinovLeon @fabioberger
 packages/devnet/ @albrow
 packages/ethereum-types/ @LogvinovLeon
-packages/metacoin/ @LogvinovLeon
 packages/monorepo-scripts/ @fabioberger
 packages/order-utils/ @fabioberger @LogvinovLeon 
 packages/python-contract-wrappers/ @feuGeneA

README.md

@@ -70,6 +70,7 @@ These packages are all under development. See [/contracts/README.md](/contracts/
 | [`@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
 
@@ -86,19 +87,17 @@ These packages are all under development. See [/contracts/README.md](/contracts/
 
 #### Utilities
 
-| Package                                                  | Version                                                                                                                 | Description                                                                  |
-| -------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
-| [`@0x/abi-gen`](/packages/abi-gen)                       | [![npm](https://img.shields.io/npm/v/@0x/abi-gen.svg)](https://www.npmjs.com/package/@0x/abi-gen)                       | Tool to generate TS wrappers from smart contract ABIs                        |
-| [`@0x/tslint-config`](/packages/tslint-config)           | [![npm](https://img.shields.io/npm/v/@0x/tslint-config.svg)](https://www.npmjs.com/package/@0x/tslint-config)           | Custom TSLint rules used by the 0x core team                                 |
-| [`@0x/types`](/packages/types)                           | [![npm](https://img.shields.io/npm/v/@0x/types.svg)](https://www.npmjs.com/package/@0x/types)                           | Shared type declarations                                                     |
-| [`@0x/typescript-typings`](/packages/typescript-typings) | [![npm](https://img.shields.io/npm/v/@0x/typescript-typings.svg)](https://www.npmjs.com/package/@0x/typescript-typings) | Repository of types for external packages                                    |
-| [`@0x/utils`](/packages/utils)                           | [![npm](https://img.shields.io/npm/v/@0x/utils.svg)](https://www.npmjs.com/package/@0x/utils)                           | Shared utilities                                                             |
-| [`@0x/react-docs`](/packages/react-docs)                 | [![npm](https://img.shields.io/npm/v/@0x/react-docs.svg)](https://www.npmjs.com/package/@0x/react-docs)                 | React documentation component for rendering TypeDoc & sol-doc generated JSON |
-| [`@0x/react-shared`](/packages/react-shared)             | [![npm](https://img.shields.io/npm/v/@0x/react-shared.svg)](https://www.npmjs.com/package/@0x/react-shared)             | 0x shared react components                                                   |
-| [`@0x/assert`](/packages/assert)                         | [![npm](https://img.shields.io/npm/v/@0x/assert.svg)](https://www.npmjs.com/package/@0x/assert)                         | Type and schema assertions used by our packages                              |
-| [`@0x/base-contract`](/packages/base-contract)           | [![npm](https://img.shields.io/npm/v/@0x/base-contract.svg)](https://www.npmjs.com/package/@0x/base-contract)           | BaseContract used by auto-generated `abi-gen` wrapper contracts              |
-| [`@0x/dev-utils`](/packages/dev-utils)                   | [![npm](https://img.shields.io/npm/v/@0x/dev-utils.svg)](https://www.npmjs.com/package/@0x/dev-utils)                   | Dev utils to be shared across 0x packages                                    |
-| [`@0x/fill-scenarios`](/packages/fill-scenarios)         | [![npm](https://img.shields.io/npm/v/@0x/fill-scenarios.svg)](https://www.npmjs.com/package/@0x/fill-scenarios)         | 0x order fill scenario generator                                             |
+| Package                                                  | Version                                                                                                                 | Description                                                     |
+| -------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
+| [`@0x/abi-gen`](/packages/abi-gen)                       | [![npm](https://img.shields.io/npm/v/@0x/abi-gen.svg)](https://www.npmjs.com/package/@0x/abi-gen)                       | Tool to generate TS wrappers from smart contract ABIs           |
+| [`@0x/tslint-config`](/packages/tslint-config)           | [![npm](https://img.shields.io/npm/v/@0x/tslint-config.svg)](https://www.npmjs.com/package/@0x/tslint-config)           | Custom TSLint rules used by the 0x core team                    |
+| [`@0x/types`](/packages/types)                           | [![npm](https://img.shields.io/npm/v/@0x/types.svg)](https://www.npmjs.com/package/@0x/types)                           | Shared type declarations                                        |
+| [`@0x/typescript-typings`](/packages/typescript-typings) | [![npm](https://img.shields.io/npm/v/@0x/typescript-typings.svg)](https://www.npmjs.com/package/@0x/typescript-typings) | Repository of types for external packages                       |
+| [`@0x/utils`](/packages/utils)                           | [![npm](https://img.shields.io/npm/v/@0x/utils.svg)](https://www.npmjs.com/package/@0x/utils)                           | Shared utilities                                                |
+| [`@0x/assert`](/packages/assert)                         | [![npm](https://img.shields.io/npm/v/@0x/assert.svg)](https://www.npmjs.com/package/@0x/assert)                         | Type and schema assertions used by our packages                 |
+| [`@0x/base-contract`](/packages/base-contract)           | [![npm](https://img.shields.io/npm/v/@0x/base-contract.svg)](https://www.npmjs.com/package/@0x/base-contract)           | BaseContract used by auto-generated `abi-gen` wrapper contracts |
+| [`@0x/dev-utils`](/packages/dev-utils)                   | [![npm](https://img.shields.io/npm/v/@0x/dev-utils.svg)](https://www.npmjs.com/package/@0x/dev-utils)                   | Dev utils to be shared across 0x packages                       |
+| [`@0x/fill-scenarios`](/packages/fill-scenarios)         | [![npm](https://img.shields.io/npm/v/@0x/fill-scenarios.svg)](https://www.npmjs.com/package/@0x/fill-scenarios)         | 0x order fill scenario generator                                |
 
 #### Private Packages
 

contracts/asset-proxy/CHANGELOG.json

@@ -1,4 +1,50 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "2.2.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "2.2.4",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564607468
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "2.2.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "2.2.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "2.2.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "version": "2.2.0",
         "changes": [

contracts/asset-proxy/CHANGELOG.md

@@ -5,6 +5,26 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v2.2.5 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v2.2.4 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v2.2.3 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v2.2.2 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v2.2.1 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v2.2.0 - _July 13, 2019_
 
     * Add `LibAssetProxyIds` contract (#1835)

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

@@ -18,349 +18,71 @@
 
 pragma solidity ^0.5.9;
 
+import "@0x/contracts-utils/contracts/src/LibBytes.sol";
+import "@0x/contracts-utils/contracts/src/SafeMath.sol";
+import "@0x/contracts-erc1155/contracts/src/interfaces/IERC1155.sol";
 import "./MixinAuthorizable.sol";
+import "./interfaces/IAssetProxy.sol";
 
 
 contract ERC1155Proxy is
-    MixinAuthorizable
+    MixinAuthorizable,
+    SafeMath,
+    IAssetProxy
 {
+    using LibBytes for bytes;
 
     // Id of this proxy.
     bytes4 constant internal PROXY_ID = bytes4(keccak256("ERC1155Assets(address,uint256[],uint256[],bytes)"));
 
-    // solhint-disable-next-line payable-fallback
-    function () 
+    /// @dev Transfers batch of ERC1155 assets. Either succeeds or throws.
+    /// @param assetData Byte array encoded with ERC1155 token address, array of ids, array of values, and callback data.
+    /// @param from Address to transfer assets from.
+    /// @param to Address to transfer assets to.
+    /// @param amount Amount that will be multiplied with each element of `assetData.values` to scale the
+    ///        values that will be transferred.
+    function transferFrom(
+        bytes calldata assetData,
+        address from,
+        address to,
+        uint256 amount
+    )
         external
+        onlyAuthorized
     {
-        // Input calldata to this function is encoded as follows:
-        //                      -- TABLE #1 --
-        // | Area     | Offset (**) | Length      | Contents                        |
-        // |----------|-------------|-------------|---------------------------------|
-        // | Header   | 0           | 4           | function selector               |
-        // | Params   |             | 4 * 32      | function parameters:            |
-        // |          | 4           |             |   1. offset to assetData (*)    |
-        // |          | 36          |             |   2. from                       |
-        // |          | 68          |             |   3. to                         |
-        // |          | 100         |             |   4. amount                     |
-        // | Data     |             |             | assetData:                      |
-        // |          | 132         | 32          | assetData Length                |
-        // |          | 164         | (see below) | assetData Contents              |
-        //
-        //
-        // Asset data is encoded as follows:
-        //                      -- TABLE #2 --
-        // | Area     | Offset      | Length  | Contents                            |
-        // |----------|-------------|---------|-------------------------------------|
-        // | Header   | 0           | 4       | assetProxyId                        |
-        // | Params   |             | 4 * 32  | function parameters:                |
-        // |          | 4           |         |   1. address of ERC1155 contract    |
-        // |          | 36          |         |   2. offset to ids (*)              |
-        // |          | 68          |         |   3. offset to values (*)           |
-        // |          | 100         |         |   4. offset to data (*)             |
-        // | Data     |             |         | ids:                                |
-        // |          | 132         | 32      |   1. ids Length                     |
-        // |          | 164         | a       |   2. ids Contents                   |
-        // |          |             |         | values:                             |
-        // |          | 164 + a     | 32      |   1. values Length                  |
-        // |          | 196 + a     | b       |   2. values Contents                |
-        // |          |             |         | data:                               |
-        // |          | 196 + a + b | 32      |   1. data Length                    |
-        // |          | 228 + a + b | c       |   2. data Contents                  |
-        //
-        //
-        // Calldata for target ERC155 asset is encoded for safeBatchTransferFrom:
-        //                      -- TABLE #3 --
-        // | Area     | Offset (**) | Length  | Contents                            |
-        // |----------|-------------|---------|-------------------------------------|
-        // | Header   | 0           | 4       | safeBatchTransferFrom selector      |
-        // | Params   |             | 5 * 32  | function parameters:                |
-        // |          | 4           |         |   1. from address                   |
-        // |          | 36          |         |   2. to address                     |
-        // |          | 68          |         |   3. offset to ids (*)              |
-        // |          | 100         |         |   4. offset to values (*)           |
-        // |          | 132         |         |   5. offset to data (*)             |
-        // | Data     |             |         | ids:                                |
-        // |          | 164         | 32      |   1. ids Length                     |
-        // |          | 196         | a       |   2. ids Contents                   |
-        // |          |             |         | values:                             |
-        // |          | 196 + a     | 32      |   1. values Length                  |
-        // |          | 228 + a     | b       |   2. values Contents                |
-        // |          |             |         | data:                               |
-        // |          | 228 + a + b | 32      |   1. data Length                    |
-        // |          | 260 + a + b | c       |   2. data Contents                  |
-        //
-        //
-        // (*): offset is computed from start of function parameters, so offset
-        //      by an additional 4 bytes in the calldata.
-        //
-        // (**): the `Offset` column is computed assuming no calldata compression;
-        //       offsets in the Data Area are dynamic and should be evaluated in
-        //       real-time.
-        //
-        // WARNING: The ABIv2 specification allows additional padding between
-        //          the Params and Data section. This will result in a larger
-        //          offset to assetData.
-        //
-        // Note: Table #1 and Table #2 exist in Calldata. We construct Table #3 in memory.
-        //
-        //
-        assembly {
-            // The first 4 bytes of calldata holds the function selector
-            let selector := and(calldataload(0), 0xffffffff00000000000000000000000000000000000000000000000000000000)
+        // Decode params from `assetData`
+        // solhint-disable indent
+        (
+            address erc1155TokenAddress,
+            uint256[] memory ids,
+            uint256[] memory values,
+            bytes memory data
+        ) = abi.decode(
+            assetData.sliceDestructive(4, assetData.length),
+            (address, uint256[], uint256[], bytes)
+        );
+        // solhint-enable indent
 
-            // `transferFrom` will be called with the following parameters:
-            // assetData Encoded byte array.
-            // from Address to transfer asset from.
-            // to Address to transfer asset to.
-            // amount Amount of asset to transfer.
-            // bytes4(keccak256("transferFrom(bytes,address,address,uint256)")) = 0xa85e59e4
-            if eq(selector, 0xa85e59e400000000000000000000000000000000000000000000000000000000) {
-
-                // To lookup a value in a mapping, we load from the storage location keccak256(k, p),
-                // where k is the key left padded to 32 bytes and p is the storage slot
-                mstore(0, caller)
-                mstore(32, authorized_slot)
-
-                 // Revert if authorized[msg.sender] == false
-                if iszero(sload(keccak256(0, 64))) {
-                    // Revert with `Error("SENDER_NOT_AUTHORIZED")`
-                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                    mstore(64, 0x0000001553454e4445525f4e4f545f415554484f52495a454400000000000000)
-                    mstore(96, 0)
-                    revert(0, 100)
-                }
-
-                // Construct Table #3 in memory, starting at memory offset 0.
-                // The algorithm below maps calldata (Table #1) and assetData (Table #2) to memory (Table #3).
-                // Once Table #3 ha been constructed in memory, the destination erc1155 contract is called using this
-                // as its calldata. This process is divided into three steps, below.
-
-                ////////// STEP 1/3 - Map calldata to memory (Table #1 -> Table #3) //////////
-
-                // Store the safeBatchTransferFrom function selector, which is computed using:
-                // bytes4(keccak256("safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)"))
-                mstore(0, 0x2eb2c2d600000000000000000000000000000000000000000000000000000000)
-
-                // Copy `from` and `to` fields from calldata (Table #1) into memory (Table #3)
-                calldatacopy(
-                    4,          // aligned such that `from` and `to` are at the correct location for Table #3
-                    36,         // beginning of `from` field from Table #1
-                    64          // 32 bytes for `from` + 32 bytes for `to` field
-                )
-
-                ////////// STEP 2/3 - Map assetData to memory (Table #2 -> Table #3) //////////
-
-                // Map relevant fields from assetData (Table #2) into memory (Table #3)
-                // The Contents column of Table #2 is the same as Table #3,
-                // beginning from parameter 3 - `offset to ids (*)`
-                // The `values` from assetData (Table #2) are multiplied by `amount` (Table #1)
-                // when they are copied into memory.
-
-                // Load offset to `assetData`
-                let assetDataOffset := add(calldataload(4), 4)
-
-                // Load length in bytes of `assetData`
-                let assetDataLength := calldataload(assetDataOffset)
-
-                // Assert that the length of asset data:
-                // 1. Must be at least 132 bytes (Table #2)
-                // 2. Must be a multiple of 32 (excluding the 4-byte selector)
-                if or(lt(assetDataLength, 132), mod(sub(assetDataLength, 4), 32)) {
-                    // Revert with `Error("INVALID_ASSET_DATA_LENGTH")`
-                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                    mstore(64, 0x00000019494e56414c49445f41535345545f444154415f4c454e475448000000)
-                    mstore(96, 0)
-                    revert(0, 100)
-                }
-
-                // End of asset data in calldata
-                // +32 for length field
-                let assetDataEnd := add(assetDataOffset, add(assetDataLength, 32))
-                if gt(assetDataEnd, calldatasize()) {
-                    // Revert with `Error("INVALID_ASSET_DATA_END")`
-                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                    mstore(64, 0x00000016494e56414c49445f41535345545f444154415f454e44000000000000)
-                    mstore(96, 0)
-                    revert(0, 100)
-                }
-
-                // Load offset to parameters section in asset data
-                let paramsInAssetDataOffset := add(assetDataOffset, 36)
-
-                // Offset of end of Data Area in memory.
-                // This value will grow as we construct Table #3.
-                let dataAreaEndOffset := 164
-
-                // Load amount by which to scale values
-                let amount := calldataload(100)
-
-                // Store pointer to `ids` (Table #3)
-                // Subtract 4 for `safeBatchTransferFrom` selector
-                mstore(68, sub(dataAreaEndOffset, 4))
-
-                // Ensure length of `ids` does not overflow
-                let idsOffset := add(paramsInAssetDataOffset, calldataload(add(assetDataOffset, 68)))
-                let idsLength := calldataload(idsOffset)
-                let idsLengthInBytes := mul(idsLength, 32)
-                if sub(div(idsLengthInBytes, 32), idsLength) {
-                    // Revert with `Error("UINT256_OVERFLOW")`
-                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                    mstore(64, 0x0000001055494e543235365f4f564552464c4f57000000000000000000000000)
-                    mstore(96, 0)
-                    revert(0, 100)
-                }
-
-                // Ensure `ids` does not resolve to outside of `assetData`
-                let idsBegin := add(idsOffset, 32)
-                let idsEnd := add(idsBegin, idsLengthInBytes)
-                if gt(idsEnd, assetDataEnd) {
-                    // Revert with `Error("INVALID_IDS_OFFSET")`
-                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                    mstore(64, 0x00000012494e56414c49445f4944535f4f464653455400000000000000000000)
-                    mstore(96, 0)
-                    revert(0, 100)
-                }
-
-                // Copy `ids` from `assetData` (Table #2) to memory (Table #3)
-                calldatacopy(
-                    dataAreaEndOffset,
-                    idsOffset,
-                    add(idsLengthInBytes, 32)
-                )
-                dataAreaEndOffset := add(dataAreaEndOffset, add(idsLengthInBytes, 32))
-
-                // Store pointer to `values` (Table #3)
-                // Subtract 4 for `safeBatchTrasferFrom` selector
-                mstore(100, sub(dataAreaEndOffset, 4))
-
-                // Ensure length of `values` does not overflow
-                let valuesOffset := add(paramsInAssetDataOffset, calldataload(add(assetDataOffset, 100)))
-                let valuesLength := calldataload(valuesOffset)
-                let valuesLengthInBytes := mul(valuesLength, 32)
-                if sub(div(valuesLengthInBytes, 32), valuesLength) {
-                    // Revert with `Error("UINT256_OVERFLOW")`
-                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                    mstore(64, 0x0000001055494e543235365f4f564552464c4f57000000000000000000000000)
-                    mstore(96, 0)
-                    revert(0, 100)
-                }
-
-                // Ensure `values` does not resolve to outside of `assetData`
-                let valuesBegin := add(valuesOffset, 32)
-                let valuesEnd := add(valuesBegin, valuesLengthInBytes)
-                if gt(valuesEnd, assetDataEnd) {
-                    // Revert with `Error("INVALID_VALUES_OFFSET")`
-                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                    mstore(64, 0x00000015494e56414c49445f56414c5545535f4f464653455400000000000000)
-                    mstore(96, 0)
-                    revert(0, 100)
-                }
-
-                // Store length of `values`
-                mstore(dataAreaEndOffset, valuesLength)
-                dataAreaEndOffset := add(dataAreaEndOffset, 32)
-
-                // Scale and store elements of `values`
-                for { let currentValueOffset := valuesBegin }
-                    lt(currentValueOffset, valuesEnd)
-                    { currentValueOffset := add(currentValueOffset, 32) }
-                {
-                    // Load value and generate scaled value
-                    let currentValue := calldataload(currentValueOffset)
-                    let currentValueScaled := mul(currentValue, amount)
-
-                    // Revert if `amount` != 0 and multiplication resulted in an overflow
-                    if iszero(or(
-                        iszero(amount),
-                        eq(div(currentValueScaled, amount), currentValue)
-                    )) {
-                        // Revert with `Error("UINT256_OVERFLOW")`
-                        mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                        mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                        mstore(64, 0x0000001055494e543235365f4f564552464c4f57000000000000000000000000)
-                        mstore(96, 0)
-                        revert(0, 100)
-                    }
-
-                    // There was no overflow, store the scaled token value
-                    mstore(dataAreaEndOffset, currentValueScaled)
-                    dataAreaEndOffset := add(dataAreaEndOffset, 32)
-                }
-
-                // Store pointer to `data` (Table #3)
-                // Subtract 4 for `safeBatchTrasferFrom` selector
-                mstore(132, sub(dataAreaEndOffset, 4))
-
-                // Ensure `data` does not resolve to outside of `assetData`
-                let dataOffset := add(paramsInAssetDataOffset, calldataload(add(assetDataOffset, 132)))
-                let dataLengthInBytes := calldataload(dataOffset)
-                let dataBegin := add(dataOffset, 32)
-                let dataEnd := add(dataBegin, dataLengthInBytes)
-                if gt(dataEnd, assetDataEnd) {
-                    // Revert with `Error("INVALID_DATA_OFFSET")`
-                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                    mstore(64, 0x00000013494e56414c49445f444154415f4f4646534554000000000000000000)
-                    mstore(96, 0)
-                    revert(0, 100)
-                }
-
-                // Copy `data` from `assetData` (Table #2) to memory (Table #3)
-                calldatacopy(
-                    dataAreaEndOffset,
-                    dataOffset,
-                    add(dataLengthInBytes, 32)
-                )
-
-                // Update the end of data offset to be word-aligned
-                let dataLengthInWords := div(add(dataLengthInBytes, 31), 32)
-                let dataLengthInBytesWordAligned := mul(dataLengthInWords, 32)
-                dataAreaEndOffset := add(dataAreaEndOffset, add(dataLengthInBytesWordAligned, 32))
-
-                ////////// STEP 3/3 - Execute Transfer //////////
-                // Load the address of the destination erc1155 contract from asset data (Table #2)
-                // +32 bytes for assetData Length
-                // +4 bytes for assetProxyId
-                let assetAddress := and(
-                    calldataload(add(assetDataOffset, 36)),
-                    0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff
-                )
-
-                // Call into the destination erc1155 contract using as calldata Table #3 (constructed in-memory above)
-                let success := call(
-                    gas,                                    // forward all gas
-                    assetAddress,                           // call address of erc1155 asset
-                    0,                                      // don't send any ETH
-                    0,                                      // pointer to start of input
-                    dataAreaEndOffset,                      // length of input is the end of the Data Area (Table #3)
-                    0,                                      // write output over memory that won't be reused
-                    0                                       // don't copy output to memory
-                )
-
-                // Revert with reason given by AssetProxy if `transferFrom` call failed
-                if iszero(success) {
-                    returndatacopy(
-                        0,                // copy to memory at 0
-                        0,                // copy from return data at 0
-                        returndatasize()  // copy all return data
-                    )
-                    revert(0, returndatasize())
-                }
-
-                // Return if call was successful
-                return(0, 0)
-            }
-
-            // Revert if undefined function is called
-            revert(0, 0)
+        // Scale values up by `amount`
+        uint256 length = values.length;
+        uint256[] memory scaledValues = new uint256[](length);
+        for (uint256 i = 0; i != length; i++) {
+            // We write the scaled values to an unused location in memory in order
+            // to avoid copying over `ids` or `data`. This is possible if they are
+            // identical to `values` and the offsets for each are pointing to the 
+            // same location in the ABI encoded calldata.
+            scaledValues[i] = safeMul(values[i], amount);
         }
+
+        // Execute `safeBatchTransferFrom` call
+        // Either succeeds or throws
+        IERC1155(erc1155TokenAddress).safeBatchTransferFrom(
+            from,
+            to,
+            ids,
+            scaledValues,
+            data
+        );
     }
 
     /// @dev Gets the proxy id associated with the proxy address.

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

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

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

@@ -18,181 +18,57 @@
 
 pragma solidity ^0.5.9;
 
+import "@0x/contracts-utils/contracts/src/LibBytes.sol";
 
+
+// solhint-disable no-unused-vars
 contract StaticCallProxy {
 
+    using LibBytes for bytes;
+
     // Id of this proxy.
     bytes4 constant internal PROXY_ID = bytes4(keccak256("StaticCall(address,bytes,bytes32)"));
 
-    // solhint-disable-next-line payable-fallback
-    function ()
+    /// @dev Makes a staticcall to a target address and verifies that the data returned matches the expected return data.
+    /// @param assetData Byte array encoded with staticCallTarget, staticCallData, and expectedCallResultHash
+    /// @param from This value is ignored.
+    /// @param to This value is ignored.
+    /// @param amount This value is ignored.
+    function transferFrom(
+        bytes calldata assetData,
+        address from,
+        address to,
+        uint256 amount
+    )
         external
+        view
     {
-        assembly {
-            // The first 4 bytes of calldata holds the function selector
-            let selector := and(calldataload(0), 0xffffffff00000000000000000000000000000000000000000000000000000000)
+        // Decode params from `assetData`
+        (
+            address staticCallTarget,
+            bytes memory staticCallData,
+            bytes32 expectedReturnDataHash
+        ) = abi.decode(
+            assetData.sliceDestructive(4, assetData.length),
+            (address, bytes, bytes32)
+        );
 
-            // `transferFrom` will be called with the following parameters:
-            // assetData Encoded byte array.
-            // from Address to transfer asset from.
-            // to Address to transfer asset to.
-            // amount Amount of asset to transfer.
-            // bytes4(keccak256("transferFrom(bytes,address,address,uint256)")) = 0xa85e59e4
-            if eq(selector, 0xa85e59e400000000000000000000000000000000000000000000000000000000) {
+        // Execute staticcall
+        (bool success, bytes memory returnData) = staticCallTarget.staticcall(staticCallData);
 
-                // `transferFrom`.
-                // The function is marked `external`, so no abi decoding is done for
-                // us. Instead, we expect the `calldata` memory to contain the
-                // following:
-                //
-                // | Area     | Offset | Length  | Contents                            |
-                // |----------|--------|---------|-------------------------------------|
-                // | Header   | 0      | 4       | function selector                   |
-                // | Params   |        | 4 * 32  | function parameters:                |
-                // |          | 4      |         |   1. offset to assetData (*)        |
-                // |          | 36     |         |   2. from                           |
-                // |          | 68     |         |   3. to                             |
-                // |          | 100    |         |   4. amount                         |
-                // | Data     |        |         | assetData:                          |
-                // |          | 132    | 32      | assetData Length                    |
-                // |          | 164    | **      | assetData Contents                  |
-                //
-                // (*): offset is computed from start of function parameters, so offset
-                //      by an additional 4 bytes in the calldata.
-                //
-                // (**): see table below to compute length of assetData Contents
-                // (***): Note that the `from`, `to`, and `amount` params in calldata are ignored in this function.
-                //
-                // WARNING: The ABIv2 specification allows additional padding between
-                //          the Params and Data section. This will result in a larger
-                //          offset to assetData.
-
-                // Load offset to `assetData`
-                let assetDataOffset := add(calldataload(4), 4)
-
-                // Validate length of `assetData`
-                let assetDataLen := calldataload(assetDataOffset)
-                if or(lt(assetDataLen, 100), mod(sub(assetDataLen, 4), 32)) {
-                    // Revert with `Error("INVALID_ASSET_DATA_LENGTH")`
-                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                    mstore(64, 0x00000019494e56414c49445f41535345545f444154415f4c454e475448000000)
-                    mstore(96, 0)
-                    revert(0, 100)
-                }
-
-                // Ensure that `assetData` ends inside of calldata
-                let assetDataEnd := add(assetDataOffset, add(assetDataLen, 32))
-                if gt(assetDataEnd, calldatasize()) {
-                    // Revert with `Error("INVALID_ASSET_DATA_END")`
-                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                    mstore(64, 0x00000016494e56414c49445f41535345545f444154415f454e44000000000000)
-                    mstore(96, 0)
-                    revert(0, 100)
-                }
-
-                // Asset data is encoded as follows:
-                // | Area     | Offset      | Length  | Contents                             |
-                // |----------|-------------|---------|--------------------------------------|
-                // | Header   | 0           | 4       | assetProxyId                         |
-                // | Params   |             | 4 * 32  | function parameters:                 |
-                // |          | 4           |         |   1. address of callTarget           |
-                // |          | 36          |         |   2. offset to staticCallData (*)    |
-                // |          | 68          |         |   3. expected 32 byte hash of output |
-                // | Data     |             |         | staticCallData:                      |
-                // |          | 100         | 32      |   1. staticCallData Length           |
-                // |          | 132         | a       |   2. staticCallData Contents         | 
-
-                // In order to find the offset to `staticCallData`, we must add:
-                // assetDataOffset
-                // + 32 (assetData len)
-                // + 4 (proxyId)
-                // + 32 (callTarget)
-                let paramsInAssetDataOffset := add(assetDataOffset, 36)
-                let staticCallDataOffset := add(paramsInAssetDataOffset, calldataload(add(assetDataOffset, 68)))
-
-                // Load length of `staticCallData`
-                let staticCallDataLen := calldataload(staticCallDataOffset)
-
-                // Ensure `staticCallData` does not begin to outside of `assetData`
-                let staticCallDataBegin := add(staticCallDataOffset, 32)
-                let staticCallDataEnd := add(staticCallDataBegin, staticCallDataLen)
-                if gt(staticCallDataEnd, assetDataEnd) {
-                    // Revert with `Error("INVALID_STATIC_CALL_DATA_OFFSET")`
-                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                    mstore(64, 0x0000001f494e56414c49445f5354415449435f43414c4c5f444154415f4f4646)
-                    mstore(96, 0x5345540000000000000000000000000000000000000000000000000000000000)
-                    revert(0, 100)
-                }
-
-                // Copy `staticCallData` into memory
-                calldatacopy(
-                    0,                              // memory can be safely overwritten from beginning
-                    staticCallDataBegin,            // start of `staticCallData`
-                    staticCallDataLen               // copy the entire `staticCallData`
-                )
-
-                // In order to find the offset to `callTarget`, we must add:
-                // assetDataOffset
-                // + 32 (assetData len)
-                // + 4 (proxyId)
-                let callTarget := and(
-                    calldataload(add(assetDataOffset, 36)),
-                    0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff
-                )
-
-                // Perform `callTarget.staticcall(staticCallData)`
-                let success := staticcall(
-                    gas,                         // forward all gas
-                    callTarget,                  // call address `callTarget`
-                    0,                           // pointer to start of input
-                    staticCallDataLen,           // length of input
-                    0,                           // start of memory can be safely overwritten
-                    0                            // don't copy output to memory
-                )
-
-                // Copy entire output to start of memory
-                let outputLen := returndatasize()
-                returndatacopy(
-                    0,                // copy to memory at 0
-                    0,                // copy from return data at 0
-                    outputLen         // copy all return data
-                )
-
-                // Revert with reason given by `callTarget` if staticcall is unsuccessful
-                if iszero(success) {
-                    revert(0, outputLen)
-                }
-
-                // Calculate hash of output
-                let callResultHash := keccak256(0, outputLen)
-
-                // In order to find the offset to `expectedCallResultHash`, we must add:
-                // assetDataOffset
-                // + 32 (assetData len)
-                // + 4 (proxyId)
-                // + 32 (callTarget)
-                // + 32 (staticCallDataOffset)
-                let expectedResultHash := calldataload(add(assetDataOffset, 100))
-
-                if sub(callResultHash, expectedResultHash) {
-                    // Revert with `Error("UNEXPECTED_STATIC_CALL_RESULT")`
-                    mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
-                    mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)
-                    mstore(64, 0x0000001d554e45585045435445445f5354415449435f43414c4c5f524553554c)
-                    mstore(96, 0x5400000000000000000000000000000000000000000000000000000000000000)
-                    revert(0, 100)
-                }
-
-                // Return if output matched expected output
-                return(0, 0)
+        // Revert with returned data if staticcall is unsuccessful
+        if (!success) {
+            assembly {
+                revert(add(returnData, 32), mload(returnData))
             }
-
-            // Revert if undefined function is called
-            revert(0, 0)
         }
+
+        // Revert if hash of return data is not as expected
+        bytes32 returnDataHash = keccak256(returnData);
+        require(
+            expectedReturnDataHash == returnDataHash,
+            "UNEXPECTED_STATIC_CALL_RESULT"
+        );
     }
 
     /// @dev Gets the proxy id associated with the proxy address.
@@ -204,4 +80,4 @@ contract StaticCallProxy {
     {
         return PROXY_ID;
     }
-}
+}

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

@@ -21,9 +21,8 @@ pragma solidity ^0.5.5;
 import "./IAuthorizable.sol";
 
 
-contract IAssetProxy is
-    IAuthorizable
-{
+contract IAssetProxy {
+
     /// @dev Transfers assets. Either succeeds or throws.
     /// @param assetData Byte array encoded for the respective asset proxy.
     /// @param from Address to transfer asset from.

contracts/asset-proxy/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-asset-proxy",
-    "version": "2.2.0",
+    "version": "2.2.5",
     "engines": {
         "node": ">=6.12"
     },
@@ -47,20 +47,21 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/protocol/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.1.0",
-        "@0x/contracts-gen": "^1.0.10",
-        "@0x/contracts-test-utils": "^3.1.8",
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/sol-compiler": "^3.1.9",
+        "@0x/abi-gen": "^4.1.0",
+        "@0x/contracts-gen": "^1.0.13",
+        "@0x/contracts-test-utils": "^3.1.13",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/sol-compiler": "^3.1.12",
         "@0x/tslint-config": "^3.0.1",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -68,17 +69,17 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.1.1",
-        "@0x/contracts-erc1155": "^1.1.7",
-        "@0x/contracts-erc20": "^2.2.6",
-        "@0x/contracts-erc721": "^2.1.7",
-        "@0x/contracts-utils": "^3.1.7",
-        "@0x/order-utils": "^8.2.0",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
-        "ethereum-types": "^2.1.3",
+        "@0x/base-contract": "^5.3.1",
+        "@0x/contracts-erc1155": "^1.1.12",
+        "@0x/contracts-erc20": "^2.2.11",
+        "@0x/contracts-erc721": "^2.1.12",
+        "@0x/contracts-utils": "^3.2.1",
+        "@0x/order-utils": "^8.2.5",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
+        "ethereum-types": "^2.1.4",
         "ethereumjs-util": "^5.1.1",
         "lodash": "^4.17.11"
     },

contracts/asset-proxy/test/authorizable.ts

@@ -37,6 +37,7 @@ describe('Authorizable', () => {
             artifacts.MixinAuthorizable,
             provider,
             txDefaults,
+            artifacts,
         );
     });
     beforeEach(async () => {

contracts/asset-proxy/test/erc1155_proxy.ts

@@ -23,7 +23,7 @@ import { LogWithDecodedArgs } from 'ethereum-types';
 import * as ethUtil from 'ethereumjs-util';
 import * as _ from 'lodash';
 
-import { ERC1155ProxyWrapper, ERC721ProxyContract } from '../src';
+import { artifacts, ERC1155ProxyContract, ERC1155ProxyWrapper } from '../src';
 
 chaiSetup.configure();
 const expect = chai.expect;
@@ -51,7 +51,7 @@ describe('ERC1155Proxy', () => {
     let receiver: string;
     let receiverContract: string;
     // contracts & wrappers
-    let erc1155Proxy: ERC721ProxyContract;
+    let erc1155Proxy: ERC1155ProxyContract;
     let erc1155Receiver: DummyERC1155ReceiverContract;
     let erc1155ProxyWrapper: ERC1155ProxyWrapper;
     let erc1155Contract: ERC1155MintableContract;
@@ -89,6 +89,7 @@ describe('ERC1155Proxy', () => {
             erc1155Artifacts.DummyERC1155Receiver,
             provider,
             txDefaults,
+            artifacts,
         );
         receiverContract = erc1155Receiver.address;
         await erc1155ProxyWrapper.setBalancesAndAllowancesAsync();
@@ -1077,7 +1078,7 @@ describe('ERC1155Proxy', () => {
             // 0x100      0000000000000000000000000000000000000000000000000000000000000004
             // 0x120      0102030400000000000000000000000000000000000000000000000000000000
             //
-            // We want to chan ge the offset to token ids to point outside the calldata.
+            // We want to change the offset to token ids to point outside the calldata.
             const encodedOffsetToTokenIds = '0000000000000000000000000000000000000000000000000000000000000080';
             const badEncodedOffsetToTokenIds = '0000000000000000000000000000000000000000000000000000000000000180';
             const assetDataWithBadTokenIdsOffset = assetData.replace(
@@ -1085,7 +1086,7 @@ describe('ERC1155Proxy', () => {
                 badEncodedOffsetToTokenIds,
             );
             // execute transfer
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 erc1155ProxyWrapper.transferFromAsync(
                     spender,
                     receiverContract,
@@ -1097,7 +1098,6 @@ describe('ERC1155Proxy', () => {
                     authorized,
                     assetDataWithBadTokenIdsOffset,
                 ),
-                RevertReason.InvalidIdsOffset,
             );
         });
         it('should revert if an element of token ids lies to outside the bounds of calldata', async () => {
@@ -1125,7 +1125,7 @@ describe('ERC1155Proxy', () => {
             // 0x100      0000000000000000000000000000000000000000000000000000000000000004
             // 0x120      0102030400000000000000000000000000000000000000000000000000000000
             //
-            // We want to chan ge the offset to token ids to the end of calldata.
+            // We want to change the offset to token ids to the end of calldata.
             // Then we'll add an invalid length: we encode length of 2 but only add 1 element.
             const encodedOffsetToTokenIds = '0000000000000000000000000000000000000000000000000000000000000080';
             const newEcodedOffsetToTokenIds = '0000000000000000000000000000000000000000000000000000000000000140';
@@ -1137,7 +1137,7 @@ describe('ERC1155Proxy', () => {
             const encodedTokenIdValues = '0000000000000000000000000000000000000000000000000000000000000001';
             const assetDataWithBadTokenIds = `${assetDataWithNewTokenIdsOffset}${encodedTokenIdsLength}${encodedTokenIdValues}`;
             // execute transfer
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 erc1155ProxyWrapper.transferFromAsync(
                     spender,
                     receiverContract,
@@ -1149,7 +1149,6 @@ describe('ERC1155Proxy', () => {
                     authorized,
                     assetDataWithBadTokenIds,
                 ),
-                RevertReason.InvalidIdsOffset,
             );
         });
         it('should revert token ids length overflows', async () => {
@@ -1177,7 +1176,7 @@ describe('ERC1155Proxy', () => {
             // 0x100      0000000000000000000000000000000000000000000000000000000000000004
             // 0x120      0102030400000000000000000000000000000000000000000000000000000000
             //
-            // We want to chan ge the offset to token ids to point to the end of calldata
+            // We want to change the offset to token ids to point to the end of calldata
             const encodedOffsetToTokenIds = '0000000000000000000000000000000000000000000000000000000000000080';
             const badEncodedOffsetToTokenIds = '0000000000000000000000000000000000000000000000000000000000000140';
             const assetDataWithBadTokenIdsOffset = assetData.replace(
@@ -1189,7 +1188,7 @@ describe('ERC1155Proxy', () => {
             const buffer = '0'.repeat(64 * 10);
             const assetDataWithOverflow = `${assetDataWithBadTokenIdsOffset}${encodedIdsLengthOverflow}${buffer}`;
             // execute transfer
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 erc1155ProxyWrapper.transferFromAsync(
                     spender,
                     receiverContract,
@@ -1201,7 +1200,6 @@ describe('ERC1155Proxy', () => {
                     authorized,
                     assetDataWithOverflow,
                 ),
-                RevertReason.Uint256Overflow,
             );
         });
         it('should revert token values length overflows', async () => {
@@ -1229,7 +1227,7 @@ describe('ERC1155Proxy', () => {
             // 0x100      0000000000000000000000000000000000000000000000000000000000000004
             // 0x120      0102030400000000000000000000000000000000000000000000000000000000
             //
-            // We want to chan ge the offset to token values to point to the end of calldata
+            // We want to change the offset to token values to point to the end of calldata
             const encodedOffsetToTokenIds = '00000000000000000000000000000000000000000000000000000000000000c0';
             const badEncodedOffsetToTokenIds = '0000000000000000000000000000000000000000000000000000000000000140';
             const assetDataWithBadTokenIdsOffset = assetData.replace(
@@ -1241,7 +1239,7 @@ describe('ERC1155Proxy', () => {
             const buffer = '0'.repeat(64 * 10);
             const assetDataWithOverflow = `${assetDataWithBadTokenIdsOffset}${encodedIdsLengthOverflow}${buffer}`;
             // execute transfer
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 erc1155ProxyWrapper.transferFromAsync(
                     spender,
                     receiverContract,
@@ -1253,7 +1251,6 @@ describe('ERC1155Proxy', () => {
                     authorized,
                     assetDataWithOverflow,
                 ),
-                RevertReason.Uint256Overflow,
             );
         });
         it('should revert token data length overflows', async () => {
@@ -1281,7 +1278,7 @@ describe('ERC1155Proxy', () => {
             // 0x100      0000000000000000000000000000000000000000000000000000000000000004
             // 0x120      0102030400000000000000000000000000000000000000000000000000000000
             //
-            // We want to chan ge the offset to token ids to point to the end of calldata,
+            // We want to change the offset to token ids to point to the end of calldata,
             // which we'll extend with a bad length.
             const encodedOffsetToTokenIds = '0000000000000000000000000000000000000000000000000000000000000100';
             const badEncodedOffsetToTokenIds = '0000000000000000000000000000000000000000000000000000000000000140';
@@ -1294,7 +1291,7 @@ describe('ERC1155Proxy', () => {
             const buffer = '0'.repeat(64 * 10);
             const assetDataWithOverflow = `${assetDataWithBadTokenIdsOffset}${encodedIdsLengthOverflow}${buffer}`;
             // execute transfer
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 erc1155ProxyWrapper.transferFromAsync(
                     spender,
                     receiverContract,
@@ -1306,7 +1303,6 @@ describe('ERC1155Proxy', () => {
                     authorized,
                     assetDataWithOverflow,
                 ),
-                RevertReason.InvalidDataOffset,
             );
         });
         it('should revert if token values resolves to outside the bounds of calldata', async () => {
@@ -1334,7 +1330,7 @@ describe('ERC1155Proxy', () => {
             // 0x100      0000000000000000000000000000000000000000000000000000000000000004
             // 0x120      0102030400000000000000000000000000000000000000000000000000000000
             //
-            // We want to chan ge the offset to token values to point outside the calldata.
+            // We want to change the offset to token values to point outside the calldata.
             const encodedOffsetToTokenValues = '00000000000000000000000000000000000000000000000000000000000000c0';
             const badEncodedOffsetToTokenValues = '00000000000000000000000000000000000000000000000000000000000001c0';
             const assetDataWithBadTokenIdsOffset = assetData.replace(
@@ -1342,7 +1338,7 @@ describe('ERC1155Proxy', () => {
                 badEncodedOffsetToTokenValues,
             );
             // execute transfer
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 erc1155ProxyWrapper.transferFromAsync(
                     spender,
                     receiverContract,
@@ -1354,7 +1350,6 @@ describe('ERC1155Proxy', () => {
                     authorized,
                     assetDataWithBadTokenIdsOffset,
                 ),
-                RevertReason.InvalidValuesOffset,
             );
         });
         it('should revert if an element of token values lies to outside the bounds of calldata', async () => {
@@ -1382,7 +1377,7 @@ describe('ERC1155Proxy', () => {
             // 0x100      0000000000000000000000000000000000000000000000000000000000000004
             // 0x120      0102030400000000000000000000000000000000000000000000000000000000
             //
-            // We want to chan ge the offset to token values to the end of calldata.
+            // We want to change the offset to token values to the end of calldata.
             // Then we'll add an invalid length: we encode length of 2 but only add 1 element.
             const encodedOffsetToTokenValues = '00000000000000000000000000000000000000000000000000000000000000c0';
             const newEcodedOffsetToTokenValues = '0000000000000000000000000000000000000000000000000000000000000140';
@@ -1394,7 +1389,7 @@ describe('ERC1155Proxy', () => {
             const encodedTokenValuesElements = '0000000000000000000000000000000000000000000000000000000000000001';
             const assetDataWithBadTokenIds = `${assetDataWithNewTokenValuesOffset}${encodedTokenValuesLength}${encodedTokenValuesElements}`;
             // execute transfer
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 erc1155ProxyWrapper.transferFromAsync(
                     spender,
                     receiverContract,
@@ -1406,7 +1401,6 @@ describe('ERC1155Proxy', () => {
                     authorized,
                     assetDataWithBadTokenIds,
                 ),
-                RevertReason.InvalidValuesOffset,
             );
         });
         it('should revert if token data resolves to outside the bounds of calldata', async () => {
@@ -1434,7 +1428,7 @@ describe('ERC1155Proxy', () => {
             // 0x100      0000000000000000000000000000000000000000000000000000000000000004
             // 0x120      0102030400000000000000000000000000000000000000000000000000000000
             //
-            // We want to chan ge the offset to token data to point outside the calldata.
+            // We want to change the offset to token data to point outside the calldata.
             const encodedOffsetToTokenData = '0000000000000000000000000000000000000000000000000000000000000100';
             const badEncodedOffsetToTokenData = '00000000000000000000000000000000000000000000000000000000000001c0';
             const assetDataWithBadTokenDataOffset = assetData.replace(
@@ -1442,7 +1436,7 @@ describe('ERC1155Proxy', () => {
                 badEncodedOffsetToTokenData,
             );
             // execute transfer
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 erc1155ProxyWrapper.transferFromAsync(
                     spender,
                     receiverContract,
@@ -1454,7 +1448,6 @@ describe('ERC1155Proxy', () => {
                     authorized,
                     assetDataWithBadTokenDataOffset,
                 ),
-                RevertReason.InvalidDataOffset,
             );
         });
         it('should revert if an element of token data lies to outside the bounds of calldata', async () => {
@@ -1482,7 +1475,7 @@ describe('ERC1155Proxy', () => {
             // 0x100      0000000000000000000000000000000000000000000000000000000000000004
             // 0x120      0102030400000000000000000000000000000000000000000000000000000000
             //
-            // We want to chan ge the offset to token data to the end of calldata.
+            // We want to change the offset to token data to the end of calldata.
             // Then we'll add an invalid length: we encode length of 33 but only add 32 elements.
             const encodedOffsetToTokenData = '0000000000000000000000000000000000000000000000000000000000000100';
             const newEcodedOffsetToTokenData = '0000000000000000000000000000000000000000000000000000000000000140';
@@ -1494,7 +1487,7 @@ describe('ERC1155Proxy', () => {
             const encodedTokenDataElements = '0000000000000000000000000000000000000000000000000000000000000001';
             const assetDataWithBadTokenData = `${assetDataWithNewTokenDataOffset}${encodedTokenDataLength}${encodedTokenDataElements}`;
             // execute transfer
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 erc1155ProxyWrapper.transferFromAsync(
                     spender,
                     receiverContract,
@@ -1506,7 +1499,6 @@ describe('ERC1155Proxy', () => {
                     authorized,
                     assetDataWithBadTokenData,
                 ),
-                RevertReason.InvalidDataOffset,
             );
         });
         it('should revert if asset data lies outside the bounds of calldata', async () => {
@@ -1536,9 +1528,8 @@ describe('ERC1155Proxy', () => {
             const invalidOffsetToAssetData = '0000000000000000000000000000000000000000000000000000000000000180';
             const badTxData = txData.replace(offsetToAssetData, invalidOffsetToAssetData);
             // execute transfer
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 erc1155ProxyWrapper.transferFromRawAsync(badTxData, authorized),
-                RevertReason.InvalidAssetDataLength,
             );
         });
         it('should revert if asset data lies outside the bounds of calldata', async () => {
@@ -1570,39 +1561,8 @@ describe('ERC1155Proxy', () => {
             const newAssetData = '0000000000000000000000000000000000000000000000000000000000000304';
             const badTxData = `${txData.replace(offsetToAssetData, invalidOffsetToAssetData)}${newAssetData}`;
             // execute transfer
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 erc1155ProxyWrapper.transferFromRawAsync(badTxData, authorized),
-                RevertReason.InvalidAssetDataEnd,
-            );
-        });
-        it('should revert if length of assetData, excluding the selector, is not a multiple of 32', async () => {
-            // setup test parameters
-            const tokensToTransfer = fungibleTokens.slice(0, 1);
-            const valuesToTransfer = [fungibleValueToTransferLarge];
-            const valueMultiplier = valueMultiplierSmall;
-            const erc1155ContractAddress = erc1155Wrapper.getContract().address;
-            const assetData = assetDataUtils.encodeERC1155AssetData(
-                erc1155ContractAddress,
-                tokensToTransfer,
-                valuesToTransfer,
-                receiverCallbackData,
-            );
-            const extraData = '01';
-            const assetDataWithExtraData = `${assetData}${extraData}`;
-            // execute transfer
-            await expectTransactionFailedAsync(
-                erc1155ProxyWrapper.transferFromAsync(
-                    spender,
-                    receiverContract,
-                    erc1155Contract.address,
-                    tokensToTransfer,
-                    valuesToTransfer,
-                    valueMultiplier,
-                    receiverCallbackData,
-                    authorized,
-                    assetDataWithExtraData,
-                ),
-                RevertReason.InvalidAssetDataLength,
             );
         });
         it('should revert if length of assetData is less than 132 bytes', async () => {
@@ -1618,7 +1578,7 @@ describe('ERC1155Proxy', () => {
             const zeros96Bytes = '0'.repeat(188);
             const assetData131Bytes = `${AssetProxyId.ERC1155}${zeros96Bytes}`;
             // execute transfer
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 erc1155ProxyWrapper.transferFromAsync(
                     spender,
                     receiverContract,
@@ -1630,7 +1590,6 @@ describe('ERC1155Proxy', () => {
                     authorized,
                     assetData131Bytes,
                 ),
-                RevertReason.InvalidAssetDataLength,
             );
         });
         it('should transfer nothing if value is zero', async () => {

contracts/asset-proxy/test/proxies.ts

@@ -23,7 +23,7 @@ import {
 } from '@0x/contracts-test-utils';
 import { BlockchainLifecycle } from '@0x/dev-utils';
 import { assetDataUtils } from '@0x/order-utils';
-import { RevertReason } from '@0x/types';
+import { AssetProxyId, RevertReason } from '@0x/types';
 import { BigNumber } from '@0x/utils';
 import * as chai from 'chai';
 import { LogWithDecodedArgs } from 'ethereum-types';
@@ -31,6 +31,7 @@ import * as _ from 'lodash';
 
 import {
     artifacts,
+    ERC1155ProxyContract,
     ERC1155ProxyWrapper,
     ERC20ProxyContract,
     ERC20Wrapper,
@@ -71,7 +72,7 @@ describe('Asset Transfer Proxies', () => {
     let erc721AFromTokenId: BigNumber;
     let erc721BFromTokenId: BigNumber;
 
-    let erc1155Proxy: ERC721ProxyContract;
+    let erc1155Proxy: ERC1155ProxyContract;
     let erc1155ProxyWrapper: ERC1155ProxyWrapper;
     let erc1155Contract: ERC1155MintableContract;
     let erc1155Contract2: ERC1155MintableContract;
@@ -100,6 +101,7 @@ describe('Asset Transfer Proxies', () => {
             artifacts.MultiAssetProxy,
             provider,
             txDefaults,
+            artifacts,
         );
 
         // Configure ERC20Proxy
@@ -172,6 +174,7 @@ describe('Asset Transfer Proxies', () => {
             erc20Artifacts.DummyNoReturnERC20Token,
             provider,
             txDefaults,
+            artifacts,
             constants.DUMMY_TOKEN_NAME,
             constants.DUMMY_TOKEN_SYMBOL,
             constants.DUMMY_TOKEN_DECIMALS,
@@ -181,6 +184,7 @@ describe('Asset Transfer Proxies', () => {
             erc20Artifacts.DummyMultipleReturnERC20Token,
             provider,
             txDefaults,
+            artifacts,
             constants.DUMMY_TOKEN_NAME,
             constants.DUMMY_TOKEN_SYMBOL,
             constants.DUMMY_TOKEN_DECIMALS,
@@ -223,6 +227,7 @@ describe('Asset Transfer Proxies', () => {
             erc721Artifacts.DummyERC721Receiver,
             provider,
             txDefaults,
+            artifacts,
         );
 
         await erc721Wrapper.setBalancesAndAllowancesAsync();
@@ -1329,7 +1334,7 @@ describe('Asset Transfer Proxies', () => {
                 const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721TokenA.address, erc721AFromTokenId);
                 const amounts = [erc20Amount, erc721Amount];
                 const nestedAssetData = [erc20AssetData, erc721AssetData];
-                const extraData = '0102030405060708';
+                const extraData = '0102030405060708090001020304050607080900010203040506070809000102';
                 const assetData = `${assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData)}${extraData}`;
                 const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
                     assetData,
@@ -1624,6 +1629,120 @@ describe('Asset Transfer Proxies', () => {
                     RevertReason.SenderNotAuthorized,
                 );
             });
+            it('should revert if asset data overflows beyond the bounds of calldata', async () => {
+                const inputAmount = new BigNumber(1);
+                const erc20Amount = new BigNumber(10);
+                const erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20TokenA.address);
+                const erc721Amount = new BigNumber(1);
+                const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721TokenA.address, erc721AFromTokenId);
+                const amounts = [erc20Amount, erc721Amount];
+                const nestedAssetData = [erc20AssetData, erc721AssetData];
+                const assetData = assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetData,
+                    fromAddress,
+                    toAddress,
+                    inputAmount,
+                );
+                // append asset data to end of tx data with a length of 0x300 bytes, which will extend past actual calldata.
+                const offsetToAssetData = '0000000000000000000000000000000000000000000000000000000000000080';
+                const invalidOffsetToAssetData = '00000000000000000000000000000000000000000000000000000000000002a0';
+                const newAssetData = '0000000000000000000000000000000000000000000000000000000000000304';
+                const badData = `${data.replace(offsetToAssetData, invalidOffsetToAssetData)}${newAssetData}`;
+                // execute transfer
+                await expectTransactionFailedAsync(
+                    web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data: badData,
+                        from: authorized,
+                    }),
+                    RevertReason.InvalidAssetDataEnd,
+                );
+            });
+            it('should revert if asset data resolves to a location beyond the bounds of calldata', async () => {
+                const inputAmount = new BigNumber(1);
+                const erc20Amount = new BigNumber(10);
+                const erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20TokenA.address);
+                const erc721Amount = new BigNumber(1);
+                const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721TokenA.address, erc721AFromTokenId);
+                const amounts = [erc20Amount, erc721Amount];
+                const nestedAssetData = [erc20AssetData, erc721AssetData];
+                const assetData = assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetData,
+                    fromAddress,
+                    toAddress,
+                    inputAmount,
+                );
+                const offsetToAssetData = '0000000000000000000000000000000000000000000000000000000000000080';
+                const invalidOffsetToAssetData = '0000000000000000000000000000000000000000000000000000000000000400';
+                const badData = data.replace(offsetToAssetData, invalidOffsetToAssetData);
+                // execute transfer
+                // note that this triggers `InvalidAssetDataLength` because the length is zero, otherwise it would
+                // trigger `InvalidAssetDataEnd`.
+                await expectTransactionFailedAsync(
+                    web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data: badData,
+                        from: authorized,
+                    }),
+                    RevertReason.InvalidAssetDataLength,
+                );
+            });
+            it('should revert if length of assetData, excluding the selector, is not a multiple of 32', async () => {
+                // setup test parameters
+                const inputAmount = new BigNumber(1);
+                const erc20Amount = new BigNumber(10);
+                const erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20TokenA.address);
+                const erc721Amount = new BigNumber(1);
+                const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721TokenA.address, erc721AFromTokenId);
+                const amounts = [erc20Amount, erc721Amount];
+                const nestedAssetData = [erc20AssetData, erc721AssetData];
+                const assetData = assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData);
+                const extraData = '01';
+                const assetDataWithExtraData = `${assetData}${extraData}`;
+                const badData = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetDataWithExtraData,
+                    fromAddress,
+                    toAddress,
+                    inputAmount,
+                );
+                // execute transfer
+                await expectTransactionFailedAsync(
+                    web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data: badData,
+                        from: authorized,
+                    }),
+                    RevertReason.InvalidAssetDataLength,
+                );
+            });
+            it('should revert if length of assetData is less than 68 bytes', async () => {
+                // setup test parameters
+                const inputAmount = new BigNumber(1);
+                // we'll construct asset data that has a 4 byte selector plus
+                // 32 byte payload. This results in asset data that is 36 bytes
+                // long and will trigger the `invalid length` error.
+                // we must be sure to use a # of bytes that is still %32
+                // so that we know the error is not triggered by another check in the code.
+                const zeros32Bytes = '0'.repeat(64);
+                const assetData36Bytes = `${AssetProxyId.MultiAsset}${zeros32Bytes}`;
+                const badData = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    assetData36Bytes,
+                    fromAddress,
+                    toAddress,
+                    inputAmount,
+                );
+                // execute transfer
+                await expectTransactionFailedAsync(
+                    web3Wrapper.sendTransactionAsync({
+                        to: multiAssetProxy.address,
+                        data: badData,
+                        from: authorized,
+                    }),
+                    RevertReason.InvalidAssetDataLength,
+                );
+            });
         });
     });
 });

contracts/asset-proxy/test/static_call_proxy.ts

@@ -41,12 +41,14 @@ describe('StaticCallProxy', () => {
             artifacts.StaticCallProxy,
             provider,
             txDefaults,
+            artifacts,
         );
         staticCallProxy = new IAssetProxyContract(staticCallProxyWithoutTransferFrom.address, provider, txDefaults);
         staticCallTarget = await TestStaticCallTargetContract.deployFrom0xArtifactAsync(
             artifacts.TestStaticCallTarget,
             provider,
             txDefaults,
+            artifacts,
         );
     });
     beforeEach(async () => {
@@ -95,26 +97,12 @@ describe('StaticCallProxy', () => {
             const invalidOffsetToAssetData = ethUtil.bufferToHex(paddedTxDataEndBuffer).slice(2);
             const newAssetData = '0000000000000000000000000000000000000000000000000000000000000304';
             const badTxData = `${txData.replace(offsetToAssetData, invalidOffsetToAssetData)}${newAssetData}`;
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 web3Wrapper.sendTransactionAsync({
                     to: staticCallProxy.address,
                     from: fromAddress,
                     data: badTxData,
                 }),
-                RevertReason.InvalidAssetDataEnd,
-            );
-        });
-        it('should revert if the length of assetData, excluding the proxyId, is not a multiple of 32', async () => {
-            const staticCallData = staticCallTarget.noInputFunction.getABIEncodedTransactionData();
-            const expectedResultHash = constants.KECCAK256_NULL;
-            const assetData = `${assetDataUtils.encodeStaticCallAssetData(
-                staticCallTarget.address,
-                staticCallData,
-                expectedResultHash,
-            )}01`;
-            await expectTransactionFailedAsync(
-                staticCallProxy.transferFrom.sendTransactionAsync(assetData, fromAddress, toAddress, amount),
-                RevertReason.InvalidAssetDataLength,
             );
         });
         it('should revert if the length of assetData is less than 100 bytes', async () => {
@@ -125,9 +113,8 @@ describe('StaticCallProxy', () => {
                 .slice(0, -128);
             const assetDataByteLen = (assetData.length - 2) / 2;
             expect((assetDataByteLen - 4) % 32).to.equal(0);
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 staticCallProxy.transferFrom.sendTransactionAsync(assetData, fromAddress, toAddress, amount),
-                RevertReason.InvalidAssetDataLength,
             );
         });
         it('should revert if the offset to `staticCallData` points to outside of assetData', async () => {
@@ -147,9 +134,8 @@ describe('StaticCallProxy', () => {
                 offsetToStaticCallData,
                 invalidOffsetToStaticCallData,
             )}${newStaticCallData}`;
-            await expectTransactionFailedAsync(
+            await expectTransactionFailedWithoutReasonAsync(
                 staticCallProxy.transferFrom.sendTransactionAsync(badAssetData, fromAddress, toAddress, amount),
-                RevertReason.InvalidStaticCallDataOffset,
             );
         });
         it('should revert if the callTarget attempts to write to state', async () => {
@@ -191,7 +177,7 @@ describe('StaticCallProxy', () => {
                 RevertReason.UnexpectedStaticCallResult,
             );
         });
-        it('should be successful if a function call with no inputs is successful', async () => {
+        it('should be successful if a function call with no inputs and no outputs is successful', async () => {
             const staticCallData = staticCallTarget.noInputFunction.getABIEncodedTransactionData();
             const expectedResultHash = constants.KECCAK256_NULL;
             const assetData = assetDataUtils.encodeStaticCallAssetData(
@@ -201,6 +187,12 @@ describe('StaticCallProxy', () => {
             );
             await staticCallProxy.transferFrom.awaitTransactionSuccessAsync(assetData, fromAddress, toAddress, amount);
         });
+        it('should be successful if the staticCallTarget is not a contract and no return value is expected', async () => {
+            const staticCallData = '0x0102030405060708';
+            const expectedResultHash = constants.KECCAK256_NULL;
+            const assetData = assetDataUtils.encodeStaticCallAssetData(toAddress, staticCallData, expectedResultHash);
+            await staticCallProxy.transferFrom.awaitTransactionSuccessAsync(assetData, fromAddress, toAddress, amount);
+        });
         it('should be successful if a function call with one static input returns the correct value', async () => {
             const staticCallData = staticCallTarget.isOddNumber.getABIEncodedTransactionData(new BigNumber(1));
             const trueAsBuffer = ethUtil.toBuffer('0x0000000000000000000000000000000000000000000000000000000000000001');

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

@@ -54,6 +54,7 @@ export class ERC1155ProxyWrapper {
                 erc1155Artifacts.ERC1155Mintable,
                 this._provider,
                 txDefaults,
+                artifacts,
             );
             const erc1155Wrapper = new Erc1155Wrapper(erc1155Contract, this._provider, this._contractOwnerAddress);
             this._dummyTokenWrappers.push(erc1155Wrapper);
@@ -69,6 +70,7 @@ export class ERC1155ProxyWrapper {
             artifacts.ERC1155Proxy,
             this._provider,
             txDefaults,
+            artifacts,
         );
         this._proxyIdIfExists = await this._proxyContract.getProxyId.callAsync();
         return this._proxyContract;

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

@@ -37,6 +37,7 @@ export class ERC20Wrapper {
                     erc20Artifacts.DummyERC20Token,
                     this._provider,
                     txDefaults,
+                    artifacts,
                     constants.DUMMY_TOKEN_NAME,
                     constants.DUMMY_TOKEN_SYMBOL,
                     decimals,
@@ -51,6 +52,7 @@ export class ERC20Wrapper {
             artifacts.ERC20Proxy,
             this._provider,
             txDefaults,
+            artifacts,
         );
         this._proxyIdIfExists = await this._proxyContract.getProxyId.callAsync();
         return this._proxyContract;

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

@@ -29,6 +29,7 @@ export class ERC721Wrapper {
                     erc721Artifacts.DummyERC721Token,
                     this._provider,
                     txDefaults,
+                    artifacts,
                     constants.DUMMY_TOKEN_NAME,
                     constants.DUMMY_TOKEN_SYMBOL,
                 ),
@@ -41,6 +42,7 @@ export class ERC721Wrapper {
             artifacts.ERC721Proxy,
             this._provider,
             txDefaults,
+            artifacts,
         );
         this._proxyIdIfExists = await this._proxyContract.getProxyId.callAsync();
         return this._proxyContract;

contracts/coordinator/CHANGELOG.json

@@ -1,4 +1,50 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "2.0.10",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "2.0.9",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564607468
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "2.0.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "2.0.7",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "2.0.6",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1563006338,
         "version": "2.0.5",

contracts/coordinator/CHANGELOG.md

@@ -5,6 +5,26 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v2.0.10 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v2.0.9 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v2.0.8 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v2.0.7 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v2.0.6 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v2.0.5 - _July 13, 2019_
 
     * Dependencies updated

contracts/coordinator/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-coordinator",
-    "version": "2.0.5",
+    "version": "2.0.10",
     "engines": {
         "node": ">=6.12"
     },
@@ -47,20 +47,21 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/extensions/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.1.0",
-        "@0x/contracts-gen": "^1.0.10",
-        "@0x/contracts-test-utils": "^3.1.8",
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/sol-compiler": "^3.1.9",
+        "@0x/abi-gen": "^4.1.0",
+        "@0x/contracts-gen": "^1.0.13",
+        "@0x/contracts-test-utils": "^3.1.13",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/sol-compiler": "^3.1.12",
         "@0x/tslint-config": "^3.0.1",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -68,18 +69,18 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.1.1",
-        "@0x/contracts-asset-proxy": "^2.2.0",
-        "@0x/contracts-erc20": "^2.2.6",
-        "@0x/contracts-exchange": "^2.1.6",
-        "@0x/contracts-exchange-libs": "^3.0.0",
-        "@0x/contracts-utils": "^3.1.7",
-        "@0x/order-utils": "^8.2.0",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
-        "ethereum-types": "^2.1.3",
+        "@0x/base-contract": "^5.3.1",
+        "@0x/contracts-asset-proxy": "^2.2.5",
+        "@0x/contracts-erc20": "^2.2.11",
+        "@0x/contracts-exchange": "^2.1.11",
+        "@0x/contracts-exchange-libs": "^3.0.5",
+        "@0x/contracts-utils": "^3.2.1",
+        "@0x/order-utils": "^8.2.5",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
+        "ethereum-types": "^2.1.4",
         "ethereumjs-util": "^5.1.1",
         "lodash": "^4.17.11"
     },

contracts/coordinator/test/coordinator.ts

@@ -74,6 +74,7 @@ describe('Coordinator tests', () => {
             exchangeArtifacts.Exchange,
             provider,
             txDefaults,
+            artifacts,
             assetDataUtils.encodeERC20AssetData(zrxToken.address),
         );
 
@@ -91,6 +92,7 @@ describe('Coordinator tests', () => {
             artifacts.Coordinator,
             provider,
             txDefaults,
+            artifacts,
             exchange.address,
         );
 

contracts/coordinator/test/libs.ts

@@ -25,6 +25,7 @@ describe('Libs tests', () => {
             artifacts.Coordinator,
             provider,
             txDefaults,
+            artifacts,
             exchangeAddress,
         );
     });

contracts/coordinator/test/mixins.ts

@@ -44,6 +44,7 @@ describe('Mixins tests', () => {
             artifacts.Coordinator,
             provider,
             txDefaults,
+            artifacts,
             exchangeAddress,
         );
         const accounts = await web3Wrapper.getAvailableAddressesAsync();

contracts/coordinator/test/utils/coordinator_registry_wrapper.ts

@@ -24,6 +24,7 @@ export class CoordinatorRegistryWrapper {
             artifacts.CoordinatorRegistry,
             this._provider,
             txDefaults,
+            artifacts,
         );
         if (this._coordinatorRegistryContract === undefined) {
             throw new Error(`Failed to deploy Coordinator Registry contract.`);

contracts/dev-utils/CHANGELOG.json

@@ -1,4 +1,59 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "0.0.7",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1564607468,
+        "version": "0.0.6",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "0.0.5",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564604963
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "0.0.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "0.0.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "0.0.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1563006338,
         "version": "0.0.2",

contracts/dev-utils/CHANGELOG.md

@@ -5,6 +5,30 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v0.0.7 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v0.0.6 - _July 31, 2019_
+
+    * Dependencies updated
+
+## v0.0.5 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v0.0.5 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v0.0.4 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v0.0.3 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v0.0.2 - _July 13, 2019_
 
     * Dependencies updated

contracts/dev-utils/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-dev-utils",
-    "version": "0.0.2",
+    "version": "0.0.7",
     "engines": {
         "node": ">=6.12"
     },
@@ -47,21 +47,21 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/dev-utils/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.1.0",
-        "@0x/contract-wrappers": "^9.1.5",
-        "@0x/contracts-gen": "^1.0.10",
-        "@0x/contracts-test-utils": "^3.1.8",
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/sol-compiler": "^3.1.9",
+        "@0x/abi-gen": "^4.1.0",
+        "@0x/contracts-gen": "^1.0.13",
+        "@0x/contracts-test-utils": "^3.1.13",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/sol-compiler": "^3.1.12",
         "@0x/tslint-config": "^3.0.1",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -69,20 +69,20 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.1.1",
-        "@0x/contracts-asset-proxy": "^2.2.0",
-        "@0x/contracts-erc1155": "^1.1.7",
-        "@0x/contracts-erc20": "^2.2.6",
-        "@0x/contracts-erc721": "^2.1.7",
-        "@0x/contracts-exchange": "^2.1.6",
-        "@0x/contracts-exchange-libs": "^3.0.0",
-        "@0x/contracts-utils": "^3.1.7",
-        "@0x/order-utils": "^8.2.0",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
-        "ethereum-types": "^2.1.3",
+        "@0x/base-contract": "^5.3.1",
+        "@0x/contracts-asset-proxy": "^2.2.5",
+        "@0x/contracts-erc1155": "^1.1.12",
+        "@0x/contracts-erc20": "^2.2.11",
+        "@0x/contracts-erc721": "^2.1.12",
+        "@0x/contracts-exchange": "^2.1.11",
+        "@0x/contracts-exchange-libs": "^3.0.5",
+        "@0x/contracts-utils": "^3.2.1",
+        "@0x/order-utils": "^8.2.5",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
+        "ethereum-types": "^2.1.4",
         "ethereumjs-util": "^5.1.1"
     },
     "publishConfig": {

contracts/dev-utils/test/lib_asset_data.ts

@@ -92,6 +92,7 @@ describe('LibAssetData', () => {
             exchangeArtifacts.Exchange,
             provider,
             txDefaults,
+            artifacts,
             constants.NULL_BYTES,
         );
 
@@ -99,26 +100,31 @@ describe('LibAssetData', () => {
             proxyArtifacts.ERC20Proxy,
             provider,
             txDefaults,
+            artifacts,
         );
         erc721Proxy = await ERC721ProxyContract.deployFrom0xArtifactAsync(
             proxyArtifacts.ERC721Proxy,
             provider,
             txDefaults,
+            artifacts,
         );
         erc1155Proxy = await ERC1155ProxyContract.deployFrom0xArtifactAsync(
             proxyArtifacts.ERC1155Proxy,
             provider,
             txDefaults,
+            artifacts,
         );
         multiAssetProxy = await MultiAssetProxyContract.deployFrom0xArtifactAsync(
             proxyArtifacts.MultiAssetProxy,
             provider,
             txDefaults,
+            artifacts,
         );
         staticCallProxy = await StaticCallProxyContract.deployFrom0xArtifactAsync(
             proxyArtifacts.StaticCallProxy,
             provider,
             txDefaults,
+            artifacts,
         );
 
         await exchange.registerAssetProxy.awaitTransactionSuccessAsync(erc20Proxy.address);
@@ -131,6 +137,7 @@ describe('LibAssetData', () => {
             artifacts.LibAssetData,
             provider,
             txDefaults,
+            artifacts,
             exchange.address,
         );
 
@@ -138,6 +145,7 @@ describe('LibAssetData', () => {
             proxyArtifacts.TestStaticCallTarget,
             provider,
             txDefaults,
+            artifacts,
         );
 
         [tokenOwnerAddress] = await web3Wrapper.getAvailableAddressesAsync();
@@ -146,6 +154,7 @@ describe('LibAssetData', () => {
             erc20Artifacts.DummyERC20Token,
             provider,
             txDefaults,
+            artifacts,
             'Dummy',
             'DUM',
             new BigNumber(1),
@@ -156,6 +165,7 @@ describe('LibAssetData', () => {
             erc721Artifacts.DummyERC721Token,
             provider,
             txDefaults,
+            artifacts,
             'Dummy',
             'DUM',
         );
@@ -172,6 +182,7 @@ describe('LibAssetData', () => {
             erc1155Artifacts.ERC1155Mintable,
             provider,
             txDefaults,
+            artifacts,
         );
 
         const logDecoder = new LogDecoder(web3Wrapper, erc1155Artifacts);

contracts/dev-utils/test/lib_transaction_decoder.ts

@@ -37,6 +37,7 @@ describe('LibTransactionDecoder', () => {
             artifacts.LibTransactionDecoder,
             provider,
             txDefaults,
+            artifacts,
         );
     });
     after(async () => {

contracts/dev-utils/test/order_validation_utils.ts

@@ -83,6 +83,7 @@ describe('OrderValidationUtils', () => {
             exchangeArtifacts.Exchange,
             provider,
             txDefaults,
+            artifacts,
             zrxAssetData,
         );
 
@@ -90,6 +91,7 @@ describe('OrderValidationUtils', () => {
             proxyArtifacts.MultiAssetProxy,
             provider,
             txDefaults,
+            artifacts,
         );
         const exchangeWrapper = new ExchangeWrapper(exchange, provider);
         await exchangeWrapper.registerAssetProxyAsync(erc20Proxy.address, owner);
@@ -102,6 +104,7 @@ describe('OrderValidationUtils', () => {
             artifacts.DevUtils,
             provider,
             txDefaults,
+            artifacts,
             exchange.address,
             zrxAssetData,
         );

contracts/erc1155/CHANGELOG.json

@@ -1,4 +1,50 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "1.1.12",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "1.1.11",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564604963
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "1.1.10",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "1.1.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "1.1.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1563006338,
         "version": "1.1.7",

contracts/erc1155/CHANGELOG.md

@@ -5,6 +5,26 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v1.1.12 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v1.1.11 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v1.1.10 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v1.1.9 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v1.1.8 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v1.1.7 - _July 13, 2019_
 
     * Dependencies updated

contracts/erc1155/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-erc1155",
-    "version": "1.1.7",
+    "version": "1.1.12",
     "engines": {
         "node": ">=6.12"
     },
@@ -47,19 +47,20 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/tokens/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.1.0",
-        "@0x/contracts-gen": "^1.0.10",
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/sol-compiler": "^3.1.9",
+        "@0x/abi-gen": "^4.1.0",
+        "@0x/contracts-gen": "^1.0.13",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/sol-compiler": "^3.1.12",
         "@0x/tslint-config": "^3.0.1",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -67,14 +68,14 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.1.1",
-        "@0x/contracts-test-utils": "^3.1.8",
-        "@0x/contracts-utils": "^3.1.7",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
-        "ethereum-types": "^2.1.3",
+        "@0x/base-contract": "^5.3.1",
+        "@0x/contracts-test-utils": "^3.1.13",
+        "@0x/contracts-utils": "^3.2.1",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
+        "ethereum-types": "^2.1.4",
         "lodash": "^4.17.11"
     },
     "publishConfig": {

contracts/erc1155/test/erc1155_token.ts

@@ -60,11 +60,13 @@ describe('ERC1155Token', () => {
             artifacts.ERC1155Mintable,
             provider,
             txDefaults,
+            artifacts,
         );
         erc1155Receiver = await DummyERC1155ReceiverContract.deployFrom0xArtifactAsync(
             artifacts.DummyERC1155Receiver,
             provider,
             txDefaults,
+            artifacts,
         );
         receiver = erc1155Receiver.address;
         // create wrapper & mint erc1155 tokens

contracts/erc20/CHANGELOG.json

@@ -1,4 +1,50 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "2.2.11",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "2.2.10",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564604963
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "2.2.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "2.2.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "2.2.7",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1563006338,
         "version": "2.2.6",

contracts/erc20/CHANGELOG.md

@@ -5,6 +5,26 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v2.2.11 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v2.2.10 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v2.2.9 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v2.2.8 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v2.2.7 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v2.2.6 - _July 13, 2019_
 
     * Dependencies updated

contracts/erc20/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-erc20",
-    "version": "2.2.6",
+    "version": "2.2.11",
     "engines": {
         "node": ">=6.12"
     },
@@ -47,20 +47,21 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/tokens/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.1.0",
-        "@0x/contracts-gen": "^1.0.10",
-        "@0x/contracts-test-utils": "^3.1.8",
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/sol-compiler": "^3.1.9",
+        "@0x/abi-gen": "^4.1.0",
+        "@0x/contracts-gen": "^1.0.13",
+        "@0x/contracts-test-utils": "^3.1.13",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/sol-compiler": "^3.1.12",
         "@0x/tslint-config": "^3.0.1",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -68,13 +69,13 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.1.1",
-        "@0x/contracts-utils": "^3.1.7",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
-        "ethereum-types": "^2.1.3",
+        "@0x/base-contract": "^5.3.1",
+        "@0x/contracts-utils": "^3.2.1",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
+        "ethereum-types": "^2.1.4",
         "lodash": "^4.17.11"
     },
     "publishConfig": {

contracts/erc20/test/unlimited_allowance_token.ts

@@ -37,6 +37,7 @@ describe('UnlimitedAllowanceToken', () => {
             artifacts.DummyERC20Token,
             provider,
             txDefaults,
+            artifacts,
             constants.DUMMY_TOKEN_NAME,
             constants.DUMMY_TOKEN_SYMBOL,
             constants.DUMMY_TOKEN_DECIMALS,

contracts/erc20/test/weth9.ts

@@ -33,10 +33,15 @@ describe('EtherToken', () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         account = accounts[0];
 
-        etherToken = await WETH9Contract.deployFrom0xArtifactAsync(artifacts.WETH9, provider, {
-            gasPrice,
-            ...txDefaults,
-        });
+        etherToken = await WETH9Contract.deployFrom0xArtifactAsync(
+            artifacts.WETH9,
+            provider,
+            {
+                gasPrice,
+                ...txDefaults,
+            },
+            artifacts,
+        );
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();

contracts/erc20/test/zrx_token.ts

@@ -26,7 +26,12 @@ describe('ZRXToken', () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         owner = accounts[0];
         spender = accounts[1];
-        zrxToken = await ZRXTokenContract.deployFrom0xArtifactAsync(artifacts.ZRXToken, provider, txDefaults);
+        zrxToken = await ZRXTokenContract.deployFrom0xArtifactAsync(
+            artifacts.ZRXToken,
+            provider,
+            txDefaults,
+            artifacts,
+        );
         MAX_UINT = constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
     });
     beforeEach(async () => {

contracts/erc721/CHANGELOG.json

@@ -1,4 +1,50 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "2.1.12",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "2.1.11",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564604963
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "2.1.10",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "2.1.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "2.1.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1563006338,
         "version": "2.1.7",

contracts/erc721/CHANGELOG.md

@@ -5,6 +5,26 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v2.1.12 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v2.1.11 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v2.1.10 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v2.1.9 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v2.1.8 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v2.1.7 - _July 13, 2019_
 
     * Dependencies updated

contracts/erc721/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-erc721",
-    "version": "2.1.7",
+    "version": "2.1.12",
     "engines": {
         "node": ">=6.12"
     },
@@ -47,20 +47,21 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/tokens/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.1.0",
-        "@0x/contracts-gen": "^1.0.10",
-        "@0x/contracts-test-utils": "^3.1.8",
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/sol-compiler": "^3.1.9",
+        "@0x/abi-gen": "^4.1.0",
+        "@0x/contracts-gen": "^1.0.13",
+        "@0x/contracts-test-utils": "^3.1.13",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/sol-compiler": "^3.1.12",
         "@0x/tslint-config": "^3.0.1",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -68,13 +69,13 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.1.1",
-        "@0x/contracts-utils": "^3.1.7",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
-        "ethereum-types": "^2.1.3",
+        "@0x/base-contract": "^5.3.1",
+        "@0x/contracts-utils": "^3.2.1",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
+        "ethereum-types": "^2.1.4",
         "lodash": "^4.17.11"
     },
     "publishConfig": {

contracts/erc721/test/erc721_token.ts

@@ -48,6 +48,7 @@ describe('ERC721Token', () => {
             artifacts.DummyERC721Token,
             provider,
             txDefaults,
+            artifacts,
             constants.DUMMY_TOKEN_NAME,
             constants.DUMMY_TOKEN_SYMBOL,
         );
@@ -55,6 +56,7 @@ describe('ERC721Token', () => {
             artifacts.DummyERC721Receiver,
             provider,
             txDefaults,
+            artifacts,
         );
         logDecoder = new LogDecoder(web3Wrapper, artifacts);
         await web3Wrapper.awaitTransactionSuccessAsync(
@@ -176,6 +178,7 @@ describe('ERC721Token', () => {
                 artifacts.DummyERC721Token,
                 provider,
                 txDefaults,
+                artifacts,
                 constants.DUMMY_TOKEN_NAME,
                 constants.DUMMY_TOKEN_SYMBOL,
             );
@@ -190,6 +193,7 @@ describe('ERC721Token', () => {
                 artifacts.InvalidERC721Receiver,
                 provider,
                 txDefaults,
+                artifacts,
             );
             const from = owner;
             const to = invalidErc721Receiver.address;
@@ -237,6 +241,7 @@ describe('ERC721Token', () => {
                 artifacts.DummyERC721Token,
                 provider,
                 txDefaults,
+                artifacts,
                 constants.DUMMY_TOKEN_NAME,
                 constants.DUMMY_TOKEN_SYMBOL,
             );
@@ -251,6 +256,7 @@ describe('ERC721Token', () => {
                 artifacts.InvalidERC721Receiver,
                 provider,
                 txDefaults,
+                artifacts,
             );
             const from = owner;
             const to = invalidErc721Receiver.address;

contracts/exchange-forwarder/CHANGELOG.json

@@ -1,4 +1,50 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "3.0.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "3.0.8",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564607468
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "3.0.7",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "3.0.6",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "3.0.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1563006338,
         "version": "3.0.4",

contracts/exchange-forwarder/CHANGELOG.md

@@ -5,6 +5,26 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v3.0.9 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v3.0.8 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v3.0.7 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v3.0.6 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v3.0.5 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v3.0.4 - _July 13, 2019_
 
     * Dependencies updated

contracts/exchange-forwarder/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-exchange-forwarder",
-    "version": "3.0.4",
+    "version": "3.0.9",
     "engines": {
         "node": ">=6.12"
     },
@@ -46,21 +46,21 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/extensions/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.1.0",
-        "@0x/contract-wrappers": "^9.1.5",
-        "@0x/contracts-gen": "^1.0.10",
-        "@0x/contracts-test-utils": "^3.1.8",
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/sol-compiler": "^3.1.9",
+        "@0x/abi-gen": "^4.1.0",
+        "@0x/contracts-gen": "^1.0.13",
+        "@0x/contracts-test-utils": "^3.1.13",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/sol-compiler": "^3.1.12",
         "@0x/tslint-config": "^3.0.1",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -68,19 +68,19 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.1.1",
-        "@0x/contracts-asset-proxy": "^2.2.0",
-        "@0x/contracts-erc20": "^2.2.6",
-        "@0x/contracts-erc721": "^2.1.7",
-        "@0x/contracts-exchange": "^2.1.6",
-        "@0x/contracts-exchange-libs": "^3.0.0",
-        "@0x/contracts-utils": "^3.1.7",
-        "@0x/order-utils": "^8.2.0",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
-        "ethereum-types": "^2.1.3",
+        "@0x/base-contract": "^5.3.1",
+        "@0x/contracts-asset-proxy": "^2.2.5",
+        "@0x/contracts-erc20": "^2.2.11",
+        "@0x/contracts-erc721": "^2.1.12",
+        "@0x/contracts-exchange": "^2.1.11",
+        "@0x/contracts-exchange-libs": "^3.0.5",
+        "@0x/contracts-utils": "^3.2.1",
+        "@0x/order-utils": "^8.2.5",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
+        "ethereum-types": "^2.1.4",
         "lodash": "^4.17.11"
     },
     "publishConfig": {

contracts/exchange-forwarder/test/forwarder.ts

@@ -32,6 +32,7 @@ const DECIMALS_DEFAULT = 18;
 const MAX_WETH_FILL_PERCENTAGE = 95;
 
 describe(ContractName.Forwarder, () => {
+    const dependencyArtifacts = { ...artifacts, ...erc20Artifacts, ...exchangeArtifacts };
     let makerAddress: string;
     let owner: string;
     let takerAddress: string;
@@ -88,7 +89,12 @@ describe(ContractName.Forwarder, () => {
         const erc721Balances = await erc721Wrapper.getBalancesAsync();
         erc721MakerAssetIds = erc721Balances[makerAddress][erc721Token.address];
 
-        wethContract = await WETH9Contract.deployFrom0xArtifactAsync(erc20Artifacts.WETH9, provider, txDefaults);
+        wethContract = await WETH9Contract.deployFrom0xArtifactAsync(
+            erc20Artifacts.WETH9,
+            provider,
+            txDefaults,
+            dependencyArtifacts,
+        );
         weth = new DummyERC20TokenContract(wethContract.address, provider);
         erc20Wrapper.addDummyTokenContract(weth);
 
@@ -98,6 +104,7 @@ describe(ContractName.Forwarder, () => {
             exchangeArtifacts.Exchange,
             provider,
             txDefaults,
+            dependencyArtifacts,
             zrxAssetData,
         );
         exchangeWrapper = new ExchangeWrapper(exchangeInstance, provider);
@@ -131,6 +138,7 @@ describe(ContractName.Forwarder, () => {
             artifacts.Forwarder,
             provider,
             txDefaults,
+            dependencyArtifacts,
             exchangeInstance.address,
             zrxAssetData,
             wethAssetData,
@@ -169,6 +177,7 @@ describe(ContractName.Forwarder, () => {
                 exchangeArtifacts.Exchange,
                 provider,
                 txDefaults,
+                dependencyArtifacts,
                 zrxAssetData,
             );
             return expectContractCreationFailedAsync(
@@ -176,6 +185,7 @@ describe(ContractName.Forwarder, () => {
                     artifacts.Forwarder,
                     provider,
                     txDefaults,
+                    dependencyArtifacts,
                     exchangeInstance.address,
                     zrxAssetData,
                     wethAssetData,

contracts/exchange-libs/CHANGELOG.json

@@ -1,4 +1,50 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "3.0.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "3.0.4",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564604963
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "3.0.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "3.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "3.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "version": "3.0.0",
         "changes": [

contracts/exchange-libs/CHANGELOG.md

@@ -5,6 +5,26 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v3.0.5 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v3.0.4 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v3.0.3 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v3.0.2 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v3.0.1 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v3.0.0 - _July 13, 2019_
 
     * Move `LibTransactionDecoder` to contracts/dev-utils package (#1848)

contracts/exchange-libs/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-exchange-libs",
-    "version": "3.0.0",
+    "version": "3.0.5",
     "engines": {
         "node": ">=6.12"
     },
@@ -47,20 +47,21 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/libs/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.1.0",
-        "@0x/contracts-gen": "^1.0.10",
-        "@0x/contracts-test-utils": "^3.1.8",
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/sol-compiler": "^3.1.9",
+        "@0x/abi-gen": "^4.1.0",
+        "@0x/contracts-gen": "^1.0.13",
+        "@0x/contracts-test-utils": "^3.1.13",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/sol-compiler": "^3.1.12",
         "@0x/tslint-config": "^3.0.1",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -68,14 +69,14 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.1.1",
-        "@0x/contracts-utils": "^3.1.7",
-        "@0x/order-utils": "^8.2.0",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
-        "ethereum-types": "^2.1.3",
+        "@0x/base-contract": "^5.3.1",
+        "@0x/contracts-utils": "^3.2.1",
+        "@0x/order-utils": "^8.2.5",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
+        "ethereum-types": "^2.1.4",
         "lodash": "^4.17.11"
     },
     "publishConfig": {

contracts/exchange-libs/test/exchange_libs.ts

@@ -35,7 +35,7 @@ describe('Exchange libs', () => {
     before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         const makerAddress = accounts[0];
-        libs = await TestLibsContract.deployFrom0xArtifactAsync(artifacts.TestLibs, provider, txDefaults);
+        libs = await TestLibsContract.deployFrom0xArtifactAsync(artifacts.TestLibs, provider, txDefaults, artifacts);
 
         const defaultOrderParams = {
             ...constants.STATIC_ORDER_PARAMS,

contracts/exchange/CHANGELOG.json

@@ -1,4 +1,50 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "2.1.11",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "2.1.10",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564607468
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "2.1.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "2.1.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "2.1.7",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1563006338,
         "version": "2.1.6",

contracts/exchange/CHANGELOG.md

@@ -5,6 +5,26 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v2.1.11 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v2.1.10 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v2.1.9 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v2.1.8 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v2.1.7 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v2.1.6 - _July 13, 2019_
 
     * Dependencies updated

contracts/exchange/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-exchange",
-    "version": "2.1.6",
+    "version": "2.1.11",
     "engines": {
         "node": ">=6.12"
     },
@@ -47,20 +47,21 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/protocol/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.1.0",
-        "@0x/contracts-gen": "^1.0.10",
-        "@0x/contracts-test-utils": "^3.1.8",
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/sol-compiler": "^3.1.9",
+        "@0x/abi-gen": "^4.1.0",
+        "@0x/contracts-gen": "^1.0.13",
+        "@0x/contracts-test-utils": "^3.1.13",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/sol-compiler": "^3.1.12",
         "@0x/tslint-config": "^3.0.1",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -68,19 +69,19 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.1.1",
-        "@0x/contracts-asset-proxy": "^2.2.0",
-        "@0x/contracts-erc1155": "^1.1.7",
-        "@0x/contracts-erc20": "^2.2.6",
-        "@0x/contracts-erc721": "^2.1.7",
-        "@0x/contracts-exchange-libs": "^3.0.0",
-        "@0x/contracts-utils": "^3.1.7",
-        "@0x/order-utils": "^8.2.0",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
-        "ethereum-types": "^2.1.3",
+        "@0x/base-contract": "^5.3.1",
+        "@0x/contracts-asset-proxy": "^2.2.5",
+        "@0x/contracts-erc1155": "^1.1.12",
+        "@0x/contracts-erc20": "^2.2.11",
+        "@0x/contracts-erc721": "^2.1.12",
+        "@0x/contracts-exchange-libs": "^3.0.5",
+        "@0x/contracts-utils": "^3.2.1",
+        "@0x/order-utils": "^8.2.5",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
+        "ethereum-types": "^2.1.4",
         "ethereumjs-util": "^5.1.1",
         "lodash": "^4.17.11"
     },

contracts/exchange/test/core.ts

@@ -1,5 +1,6 @@
 import {
     artifacts as proxyArtifacts,
+    ERC1155ProxyContract,
     ERC1155ProxyWrapper,
     ERC20ProxyContract,
     ERC20Wrapper,
@@ -50,6 +51,8 @@ import {
     TestStaticCallReceiverContract,
 } from '../src';
 
+import { dependencyArtifacts } from './utils/dependency_artifacts';
+
 chaiSetup.configure();
 const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
@@ -69,7 +72,7 @@ describe('Exchange core', () => {
     let exchange: ExchangeContract;
     let erc20Proxy: ERC20ProxyContract;
     let erc721Proxy: ERC721ProxyContract;
-    let erc1155Proxy: ERC721ProxyContract;
+    let erc1155Proxy: ERC1155ProxyContract;
     let multiAssetProxy: MultiAssetProxyContract;
     let staticCallProxy: StaticCallProxyContract;
     let staticCallTarget: TestStaticCallTargetContract;
@@ -116,11 +119,13 @@ describe('Exchange core', () => {
             proxyArtifacts.MultiAssetProxy,
             provider,
             txDefaults,
+            dependencyArtifacts,
         );
         staticCallProxy = await StaticCallProxyContract.deployFrom0xArtifactAsync(
             proxyArtifacts.StaticCallProxy,
             provider,
             txDefaults,
+            dependencyArtifacts,
         );
         const numDummyErc20ToDeploy = 3;
         [erc20TokenA, erc20TokenB, zrxToken] = await erc20Wrapper.deployDummyTokensAsync(
@@ -135,17 +140,20 @@ describe('Exchange core', () => {
             artifacts.Exchange,
             provider,
             txDefaults,
+            dependencyArtifacts,
             assetDataUtils.encodeERC20AssetData(zrxToken.address),
         );
         maliciousWallet = maliciousValidator = await TestStaticCallReceiverContract.deployFrom0xArtifactAsync(
             artifacts.TestStaticCallReceiver,
             provider,
             txDefaults,
+            dependencyArtifacts,
         );
         reentrantErc20Token = await ReentrantERC20TokenContract.deployFrom0xArtifactAsync(
             artifacts.ReentrantERC20Token,
             provider,
             txDefaults,
+            dependencyArtifacts,
             exchange.address,
         );
 
@@ -348,6 +356,7 @@ describe('Exchange core', () => {
                 erc20Artifacts.DummyNoReturnERC20Token,
                 provider,
                 txDefaults,
+                dependencyArtifacts,
                 constants.DUMMY_TOKEN_NAME,
                 constants.DUMMY_TOKEN_SYMBOL,
                 constants.DUMMY_TOKEN_DECIMALS,
@@ -1473,6 +1482,7 @@ describe('Exchange core', () => {
                 proxyArtifacts.TestStaticCallTarget,
                 provider,
                 txDefaults,
+                dependencyArtifacts,
             );
         });
         it('should revert if the staticcall is unsuccessful', async () => {

contracts/exchange/test/dispatcher.ts

@@ -29,6 +29,8 @@ import {
     TestAssetProxyDispatcherContract,
 } from '../src';
 
+import { dependencyArtifacts } from './utils/dependency_artifacts';
+
 chaiSetup.configure();
 const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
@@ -72,6 +74,7 @@ describe('AssetProxyDispatcher', () => {
             artifacts.TestAssetProxyDispatcher,
             provider,
             txDefaults,
+            dependencyArtifacts,
         );
         await web3Wrapper.awaitTransactionSuccessAsync(
             await erc20Proxy.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcher.address, {
@@ -134,6 +137,7 @@ describe('AssetProxyDispatcher', () => {
                 proxyArtifacts.ERC20Proxy,
                 provider,
                 txDefaults,
+                dependencyArtifacts,
             );
             // Register new ERC20 Transfer Proxy contract
             return expectTransactionFailedAsync(

contracts/exchange/test/internal.ts

@@ -18,6 +18,8 @@ import * as _ from 'lodash';
 
 import { artifacts, TestExchangeInternalsContract } from '../src';
 
+import { dependencyArtifacts } from './utils/dependency_artifacts';
+
 chaiSetup.configure();
 const expect = chai.expect;
 
@@ -65,6 +67,7 @@ describe('Exchange core internal functions', () => {
             artifacts.TestExchangeInternals,
             provider,
             txDefaults,
+            dependencyArtifacts,
         );
         overflowErrorForSendTransaction = new Error(
             await getRevertReasonOrErrorMessageForSendTransactionAsync(RevertReason.Uint256Overflow),

contracts/exchange/test/match_orders.ts

@@ -29,6 +29,8 @@ import {
     TestExchangeInternalsContract,
 } from '../src';
 
+import { dependencyArtifacts } from './utils/dependency_artifacts';
+
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 chaiSetup.configure();
 const expect = chai.expect;
@@ -118,6 +120,7 @@ describe('matchOrders', () => {
             artifacts.Exchange,
             provider,
             txDefaults,
+            dependencyArtifacts,
             assetDataUtils.encodeERC20AssetData(zrxToken.address),
         );
         exchangeWrapper = new ExchangeWrapper(exchange, provider);
@@ -141,6 +144,7 @@ describe('matchOrders', () => {
             artifacts.ReentrantERC20Token,
             provider,
             txDefaults,
+            dependencyArtifacts,
             exchange.address,
         );
 
@@ -175,6 +179,7 @@ describe('matchOrders', () => {
             artifacts.TestExchangeInternals,
             provider,
             txDefaults,
+            dependencyArtifacts,
         );
     });
     beforeEach(async () => {

contracts/exchange/test/signature_validator.ts

@@ -25,6 +25,8 @@ import {
     WalletContract,
 } from '../src';
 
+import { dependencyArtifacts } from './utils/dependency_artifacts';
+
 chaiSetup.configure();
 const expect = chai.expect;
 
@@ -59,23 +61,27 @@ describe('MixinSignatureValidator', () => {
             artifacts.TestSignatureValidator,
             provider,
             txDefaults,
+            dependencyArtifacts,
         );
         testWallet = await WalletContract.deployFrom0xArtifactAsync(
             artifacts.Wallet,
             provider,
             txDefaults,
+            dependencyArtifacts,
             signerAddress,
         );
         testValidator = await ValidatorContract.deployFrom0xArtifactAsync(
             artifacts.Validator,
             provider,
             txDefaults,
+            dependencyArtifacts,
             signerAddress,
         );
         maliciousWallet = maliciousValidator = await TestStaticCallReceiverContract.deployFrom0xArtifactAsync(
             artifacts.TestStaticCallReceiver,
             provider,
             txDefaults,
+            dependencyArtifacts,
         );
         signatureValidatorLogDecoder = new LogDecoder(web3Wrapper, artifacts);
         await web3Wrapper.awaitTransactionSuccessAsync(

contracts/exchange/test/transactions.ts

@@ -21,6 +21,8 @@ import * as _ from 'lodash';
 
 import { artifacts, ExchangeContract, ExchangeWrapper, ExchangeWrapperContract, WhitelistContract } from '../src/';
 
+import { dependencyArtifacts } from './utils/dependency_artifacts';
+
 chaiSetup.configure();
 const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
@@ -87,6 +89,7 @@ describe('Exchange transactions', () => {
             artifacts.Exchange,
             provider,
             txDefaults,
+            dependencyArtifacts,
             assetDataUtils.encodeERC20AssetData(zrxToken.address),
         );
         exchangeWrapper = new ExchangeWrapper(exchange, provider);
@@ -219,6 +222,7 @@ describe('Exchange transactions', () => {
                     artifacts.ExchangeWrapper,
                     provider,
                     txDefaults,
+                    dependencyArtifacts,
                     exchange.address,
                 );
             });
@@ -333,6 +337,7 @@ describe('Exchange transactions', () => {
                 artifacts.Whitelist,
                 provider,
                 txDefaults,
+                dependencyArtifacts,
                 exchange.address,
             );
             const isApproved = true;

contracts/exchange/test/utils/dependency_artifacts.ts

@@ -0,0 +1,9 @@
+import { artifacts as erc1155Artifacts } from '@0x/contracts-erc1155';
+import { artifacts as erc20Artifacts } from '@0x/contracts-erc20';
+import { artifacts as erc721Artifacts } from '@0x/contracts-erc721';
+
+export const dependencyArtifacts = {
+    ...erc20Artifacts,
+    ...erc721Artifacts,
+    ...erc1155Artifacts,
+};

contracts/exchange/test/utils/exchange_wrapper.ts

@@ -1,37 +1,21 @@
-import { artifacts as erc1155Artifacts } from '@0x/contracts-erc1155';
-import { artifacts as erc20Artifacts } from '@0x/contracts-erc20';
-import { artifacts as erc721Artifacts } from '@0x/contracts-erc721';
-import {
-    FillResults,
-    formatters,
-    LogDecoder,
-    OrderInfo,
-    orderUtils,
-    Web3ProviderEngine,
-} from '@0x/contracts-test-utils';
+import { FillResults, formatters, OrderInfo, orderUtils, Web3ProviderEngine } from '@0x/contracts-test-utils';
 import { SignedOrder, SignedZeroExTransaction } from '@0x/types';
 import { AbiEncoder, BigNumber } from '@0x/utils';
 import { Web3Wrapper } from '@0x/web3-wrapper';
 import { MethodAbi, TransactionReceiptWithDecodedLogs, ZeroExProvider } from 'ethereum-types';
 import * as _ from 'lodash';
 
-import { artifacts, ExchangeContract } from '../../src';
+import { ExchangeContract } from '../../src';
 
 import { AbiDecodedFillOrderData } from './types';
 
 export class ExchangeWrapper {
     private readonly _exchange: ExchangeContract;
+    // tslint:disable no-unused-variable
     private readonly _web3Wrapper: Web3Wrapper;
-    private readonly _logDecoder: LogDecoder;
     constructor(exchangeContract: ExchangeContract, provider: Web3ProviderEngine | ZeroExProvider) {
         this._exchange = exchangeContract;
         this._web3Wrapper = new Web3Wrapper(provider);
-        this._logDecoder = new LogDecoder(this._web3Wrapper, {
-            ...artifacts,
-            ...erc20Artifacts,
-            ...erc721Artifacts,
-            ...erc1155Artifacts,
-        });
     }
     public async fillOrderAsync(
         signedOrder: SignedOrder,
@@ -39,20 +23,18 @@ export class ExchangeWrapper {
         opts: { takerAssetFillAmount?: BigNumber } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = orderUtils.createFill(signedOrder, opts.takerAssetFillAmount);
-        const txHash = await this._exchange.fillOrder.sendTransactionAsync(
+        const txReceipt = await this._exchange.fillOrder.awaitTransactionSuccessAsync(
             params.order,
             params.takerAssetFillAmount,
             params.signature,
             { from },
         );
-        const txReceipt = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
         return txReceipt;
     }
     public async cancelOrderAsync(signedOrder: SignedOrder, from: string): Promise<TransactionReceiptWithDecodedLogs> {
         const params = orderUtils.createCancel(signedOrder);
-        const txHash = await this._exchange.cancelOrder.sendTransactionAsync(params.order, { from });
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        const txReceipt = await this._exchange.cancelOrder.awaitTransactionSuccessAsync(params.order, { from });
+        return txReceipt;
     }
     public async fillOrKillOrderAsync(
         signedOrder: SignedOrder,
@@ -60,14 +42,13 @@ export class ExchangeWrapper {
         opts: { takerAssetFillAmount?: BigNumber } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = orderUtils.createFill(signedOrder, opts.takerAssetFillAmount);
-        const txHash = await this._exchange.fillOrKillOrder.sendTransactionAsync(
+        const txReceipt = await this._exchange.fillOrKillOrder.awaitTransactionSuccessAsync(
             params.order,
             params.takerAssetFillAmount,
             params.signature,
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return txReceipt;
     }
     public async fillOrderNoThrowAsync(
         signedOrder: SignedOrder,
@@ -75,14 +56,13 @@ export class ExchangeWrapper {
         opts: { takerAssetFillAmount?: BigNumber; gas?: number } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = orderUtils.createFill(signedOrder, opts.takerAssetFillAmount);
-        const txHash = await this._exchange.fillOrderNoThrow.sendTransactionAsync(
+        const txReceipt = await this._exchange.fillOrderNoThrow.awaitTransactionSuccessAsync(
             params.order,
             params.takerAssetFillAmount,
             params.signature,
             { from, gas: opts.gas },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return txReceipt;
     }
     public async batchFillOrdersAsync(
         orders: SignedOrder[],
@@ -90,14 +70,13 @@ export class ExchangeWrapper {
         opts: { takerAssetFillAmounts?: BigNumber[] } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = formatters.createBatchFill(orders, opts.takerAssetFillAmounts);
-        const txHash = await this._exchange.batchFillOrders.sendTransactionAsync(
+        const txReceipt = await this._exchange.batchFillOrders.awaitTransactionSuccessAsync(
             params.orders,
             params.takerAssetFillAmounts,
             params.signatures,
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return txReceipt;
     }
     public async batchFillOrKillOrdersAsync(
         orders: SignedOrder[],
@@ -105,14 +84,13 @@ export class ExchangeWrapper {
         opts: { takerAssetFillAmounts?: BigNumber[] } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = formatters.createBatchFill(orders, opts.takerAssetFillAmounts);
-        const txHash = await this._exchange.batchFillOrKillOrders.sendTransactionAsync(
+        const txReceipt = await this._exchange.batchFillOrKillOrders.awaitTransactionSuccessAsync(
             params.orders,
             params.takerAssetFillAmounts,
             params.signatures,
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return txReceipt;
     }
     public async batchFillOrdersNoThrowAsync(
         orders: SignedOrder[],
@@ -120,14 +98,13 @@ export class ExchangeWrapper {
         opts: { takerAssetFillAmounts?: BigNumber[]; gas?: number } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = formatters.createBatchFill(orders, opts.takerAssetFillAmounts);
-        const txHash = await this._exchange.batchFillOrdersNoThrow.sendTransactionAsync(
+        const txReceipt = await this._exchange.batchFillOrdersNoThrow.awaitTransactionSuccessAsync(
             params.orders,
             params.takerAssetFillAmounts,
             params.signatures,
             { from, gas: opts.gas },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return txReceipt;
     }
     public async marketSellOrdersAsync(
         orders: SignedOrder[],
@@ -135,14 +112,13 @@ export class ExchangeWrapper {
         opts: { takerAssetFillAmount: BigNumber },
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = formatters.createMarketSellOrders(orders, opts.takerAssetFillAmount);
-        const txHash = await this._exchange.marketSellOrders.sendTransactionAsync(
+        const txReceipt = await this._exchange.marketSellOrders.awaitTransactionSuccessAsync(
             params.orders,
             params.takerAssetFillAmount,
             params.signatures,
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return txReceipt;
     }
     public async marketSellOrdersNoThrowAsync(
         orders: SignedOrder[],
@@ -150,14 +126,13 @@ export class ExchangeWrapper {
         opts: { takerAssetFillAmount: BigNumber; gas?: number },
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = formatters.createMarketSellOrders(orders, opts.takerAssetFillAmount);
-        const txHash = await this._exchange.marketSellOrdersNoThrow.sendTransactionAsync(
+        const txReceipt = await this._exchange.marketSellOrdersNoThrow.awaitTransactionSuccessAsync(
             params.orders,
             params.takerAssetFillAmount,
             params.signatures,
             { from, gas: opts.gas },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return txReceipt;
     }
     public async marketBuyOrdersAsync(
         orders: SignedOrder[],
@@ -165,14 +140,13 @@ export class ExchangeWrapper {
         opts: { makerAssetFillAmount: BigNumber },
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = formatters.createMarketBuyOrders(orders, opts.makerAssetFillAmount);
-        const txHash = await this._exchange.marketBuyOrders.sendTransactionAsync(
+        const txReceipt = await this._exchange.marketBuyOrders.awaitTransactionSuccessAsync(
             params.orders,
             params.makerAssetFillAmount,
             params.signatures,
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return txReceipt;
     }
     public async marketBuyOrdersNoThrowAsync(
         orders: SignedOrder[],
@@ -180,50 +154,47 @@ export class ExchangeWrapper {
         opts: { makerAssetFillAmount: BigNumber; gas?: number },
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = formatters.createMarketBuyOrders(orders, opts.makerAssetFillAmount);
-        const txHash = await this._exchange.marketBuyOrdersNoThrow.sendTransactionAsync(
+        const txReceipt = await this._exchange.marketBuyOrdersNoThrow.awaitTransactionSuccessAsync(
             params.orders,
             params.makerAssetFillAmount,
             params.signatures,
             { from, gas: opts.gas },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return txReceipt;
     }
     public async batchCancelOrdersAsync(
         orders: SignedOrder[],
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = formatters.createBatchCancel(orders);
-        const txHash = await this._exchange.batchCancelOrders.sendTransactionAsync(params.orders, { from });
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        const txReceipt = await this._exchange.batchCancelOrders.awaitTransactionSuccessAsync(params.orders, { from });
+        return txReceipt;
     }
     public async cancelOrdersUpToAsync(salt: BigNumber, from: string): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.cancelOrdersUpTo.sendTransactionAsync(salt, { from });
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        const txReceipt = await this._exchange.cancelOrdersUpTo.awaitTransactionSuccessAsync(salt, { from });
+        return txReceipt;
     }
     public async registerAssetProxyAsync(
         assetProxyAddress: string,
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.registerAssetProxy.sendTransactionAsync(assetProxyAddress, { from });
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        const txReceipt = await this._exchange.registerAssetProxy.awaitTransactionSuccessAsync(assetProxyAddress, {
+            from,
+        });
+        return txReceipt;
     }
     public async executeTransactionAsync(
         signedTx: SignedZeroExTransaction,
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.executeTransaction.sendTransactionAsync(
+        const txReceipt = await this._exchange.executeTransaction.awaitTransactionSuccessAsync(
             signedTx.salt,
             signedTx.signerAddress,
             signedTx.data,
             signedTx.signature,
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return txReceipt;
     }
     public async getTakerAssetFilledAmountAsync(orderHashHex: string): Promise<BigNumber> {
         const filledAmount = await this._exchange.filled.callAsync(orderHashHex);
@@ -251,15 +222,14 @@ export class ExchangeWrapper {
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = orderUtils.createMatchOrders(signedOrderLeft, signedOrderRight);
-        const txHash = await this._exchange.matchOrders.sendTransactionAsync(
+        const txReceipt = await this._exchange.matchOrders.awaitTransactionSuccessAsync(
             params.left,
             params.right,
             params.leftSignature,
             params.rightSignature,
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return txReceipt;
     }
     public async getFillOrderResultsAsync(
         signedOrder: SignedOrder,

contracts/exchange/test/utils/fill_order_combinatorial_utils.ts

@@ -37,6 +37,7 @@ import 'make-promises-safe';
 import { artifacts, ExchangeContract, ExchangeFillEventArgs } from '../../src';
 
 import { AssetWrapper } from './asset_wrapper';
+import { dependencyArtifacts } from './dependency_artifacts';
 import { ExchangeWrapper } from './exchange_wrapper';
 import { OrderFactoryFromScenario } from './order_factory_from_scenario';
 import { SimpleAssetBalanceAndProxyAllowanceFetcher } from './simple_asset_balance_and_proxy_allowance_fetcher';
@@ -101,6 +102,7 @@ export async function fillOrderCombinatorialUtilsFactoryAsync(
         artifacts.Exchange,
         provider,
         txDefaults,
+        dependencyArtifacts,
         zrxAssetData,
     );
     const exchangeWrapper = new ExchangeWrapper(exchangeContract, provider);
@@ -135,6 +137,7 @@ export async function fillOrderCombinatorialUtilsFactoryAsync(
         libsArtifacts.TestLibs,
         provider,
         txDefaults,
+        dependencyArtifacts,
     );
 
     const fillOrderCombinatorialUtils = new FillOrderCombinatorialUtils(

contracts/exchange/test/wrapper.ts

@@ -24,6 +24,8 @@ import * as _ from 'lodash';
 
 import { artifacts, ExchangeContract, ExchangeWrapper, ReentrantERC20TokenContract } from '../src';
 
+import { dependencyArtifacts } from './utils/dependency_artifacts';
+
 chaiSetup.configure();
 const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
@@ -87,6 +89,7 @@ describe('Exchange wrappers', () => {
             artifacts.Exchange,
             provider,
             txDefaults,
+            dependencyArtifacts,
             assetDataUtils.encodeERC20AssetData(zrxToken.address),
         );
         exchangeWrapper = new ExchangeWrapper(exchange, provider);
@@ -110,6 +113,7 @@ describe('Exchange wrappers', () => {
             artifacts.ReentrantERC20Token,
             provider,
             txDefaults,
+            dependencyArtifacts,
             exchange.address,
         );
 

contracts/extensions/CHANGELOG.json

@@ -1,4 +1,50 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "4.0.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "4.0.4",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564607468
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "4.0.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "4.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "4.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "version": "4.0.0",
         "changes": [

contracts/extensions/CHANGELOG.md

@@ -5,6 +5,26 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v4.0.5 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v4.0.4 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v4.0.3 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v4.0.2 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v4.0.1 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v4.0.0 - _July 13, 2019_
 
     * Move `OrderValidator` to contracts/dev-utils package as `OrderValidationUtils` (#1848)

contracts/extensions/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-extensions",
-    "version": "4.0.0",
+    "version": "4.0.5",
     "engines": {
         "node": ">=6.12"
     },
@@ -47,21 +47,22 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/extensions/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.1.0",
-        "@0x/contract-wrappers": "^9.1.5",
-        "@0x/contracts-gen": "^1.0.10",
-        "@0x/contracts-test-utils": "^3.1.8",
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/sol-compiler": "^3.1.9",
+        "@0x/abi-gen": "^4.1.0",
+        "@0x/contract-wrappers": "9.1.7",
+        "@0x/contracts-gen": "^1.0.13",
+        "@0x/contracts-test-utils": "^3.1.13",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/sol-compiler": "^3.1.12",
         "@0x/tslint-config": "^3.0.1",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -69,19 +70,19 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.1.1",
-        "@0x/contracts-asset-proxy": "^2.2.0",
-        "@0x/contracts-erc20": "^2.2.6",
-        "@0x/contracts-erc721": "^2.1.7",
-        "@0x/contracts-exchange": "^2.1.6",
-        "@0x/contracts-exchange-libs": "^3.0.0",
-        "@0x/contracts-utils": "^3.1.7",
-        "@0x/order-utils": "^8.2.0",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
-        "ethereum-types": "^2.1.3",
+        "@0x/base-contract": "^5.3.1",
+        "@0x/contracts-asset-proxy": "^2.2.5",
+        "@0x/contracts-erc20": "^2.2.11",
+        "@0x/contracts-erc721": "^2.1.12",
+        "@0x/contracts-exchange": "^2.1.11",
+        "@0x/contracts-exchange-libs": "^3.0.5",
+        "@0x/contracts-utils": "^3.2.1",
+        "@0x/order-utils": "^8.2.5",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
+        "ethereum-types": "^2.1.4",
         "lodash": "^4.17.11"
     },
     "publishConfig": {

contracts/extensions/test/balance_threshold_filter.ts

@@ -130,6 +130,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
             artifacts.Exchange,
             provider,
             txDefaults,
+            artifacts,
             zrxAssetData,
         );
         exchangeWrapper = new ExchangeWrapper(exchangeInstance, provider);
@@ -148,6 +149,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
             artifacts.BalanceThresholdFilter,
             provider,
             txDefaults,
+            artifacts,
             exchangeInstance.address,
             erc721BalanceThresholdAsset.address,
             erc721alanceThreshold,
@@ -157,6 +159,7 @@ describe(ContractName.BalanceThresholdFilter, () => {
             artifacts.BalanceThresholdFilter,
             provider,
             txDefaults,
+            artifacts,
             exchangeInstance.address,
             erc20BalanceThresholdAsset.address,
             erc20BalanceThreshold,

contracts/extensions/test/dutch_auction.ts

@@ -82,7 +82,7 @@ describe(ContractName.DutchAuction, () => {
         const erc721Balances = await erc721Wrapper.getBalancesAsync();
         erc721MakerAssetIds = erc721Balances[makerAddress][erc721Token.address];
 
-        wethContract = await WETH9Contract.deployFrom0xArtifactAsync(artifacts.WETH9, provider, txDefaults);
+        wethContract = await WETH9Contract.deployFrom0xArtifactAsync(artifacts.WETH9, provider, txDefaults, artifacts);
         erc20Wrapper.addDummyTokenContract(wethContract as any);
 
         const zrxAssetData = assetDataUtils.encodeERC20AssetData(zrxToken.address);
@@ -90,6 +90,7 @@ describe(ContractName.DutchAuction, () => {
             artifacts.Exchange,
             provider,
             txDefaults,
+            artifacts,
             zrxAssetData,
         );
         const exchangeWrapper = new ExchangeWrapper(exchangeInstance, provider);
@@ -107,6 +108,7 @@ describe(ContractName.DutchAuction, () => {
             artifacts.DutchAuction,
             provider,
             txDefaults,
+            artifacts,
             exchangeInstance.address,
         );
         dutchAuctionContract = new DutchAuctionContract(dutchAuctionInstance.address, provider);

contracts/extensions/test/order_matcher.ts

@@ -103,12 +103,14 @@ describe('OrderMatcher', () => {
             proxyArtifacts.ERC721Proxy,
             provider,
             txDefaults,
+            artifacts,
         );
         // Depoy exchange
         exchange = await ExchangeContract.deployFrom0xArtifactAsync(
             artifacts.Exchange,
             provider,
             txDefaults,
+            artifacts,
             assetDataUtils.encodeERC20AssetData(zrxToken.address),
         );
         exchangeWrapper = new ExchangeWrapper(exchange, provider);
@@ -126,6 +128,7 @@ describe('OrderMatcher', () => {
             artifacts.OrderMatcher,
             provider,
             txDefaults,
+            artifacts,
             exchange.address,
         );
         // Set default addresses
@@ -198,6 +201,7 @@ describe('OrderMatcher', () => {
                 artifacts.Exchange,
                 provider,
                 txDefaults,
+                artifacts,
                 constants.NULL_BYTES,
             );
             return expectContractCreationFailedAsync(
@@ -205,6 +209,7 @@ describe('OrderMatcher', () => {
                     artifacts.OrderMatcher,
                     provider,
                     txDefaults,
+                    artifacts,
                     exchangeInstance.address,
                 ) as any) as sendTransactionResult,
                 RevertReason.UnregisteredAssetProxy,
@@ -727,6 +732,7 @@ describe('OrderMatcher', () => {
                 erc721Artifacts.DummyERC721Token,
                 provider,
                 txDefaults,
+                artifacts,
                 constants.DUMMY_TOKEN_NAME,
                 constants.DUMMY_TOKEN_SYMBOL,
             );
@@ -772,6 +778,7 @@ describe('OrderMatcher', () => {
                 erc721Artifacts.DummyERC721Token,
                 provider,
                 txDefaults,
+                artifacts,
                 constants.DUMMY_TOKEN_NAME,
                 constants.DUMMY_TOKEN_SYMBOL,
             );
@@ -789,6 +796,7 @@ describe('OrderMatcher', () => {
                 erc721Artifacts.DummyERC721Token,
                 provider,
                 txDefaults,
+                artifacts,
                 constants.DUMMY_TOKEN_NAME,
                 constants.DUMMY_TOKEN_SYMBOL,
             );

contracts/multisig/CHANGELOG.json

@@ -1,4 +1,50 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "3.1.11",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "3.1.10",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564607468
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "3.1.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "3.1.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "3.1.7",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1563006338,
         "version": "3.1.6",

contracts/multisig/CHANGELOG.md

@@ -5,6 +5,26 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v3.1.11 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v3.1.10 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+
+## v3.1.9 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v3.1.8 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v3.1.7 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v3.1.6 - _July 13, 2019_
 
     * Dependencies updated

contracts/multisig/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-multisig",
-    "version": "3.1.6",
+    "version": "3.1.11",
     "engines": {
         "node": ">=6.12"
     },
@@ -47,20 +47,21 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/multisig/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.1.0",
-        "@0x/contracts-gen": "^1.0.10",
-        "@0x/contracts-test-utils": "^3.1.8",
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/sol-compiler": "^3.1.9",
+        "@0x/abi-gen": "^4.1.0",
+        "@0x/contracts-gen": "^1.0.13",
+        "@0x/contracts-test-utils": "^3.1.13",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/sol-compiler": "^3.1.12",
         "@0x/tslint-config": "^3.0.1",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -68,15 +69,15 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.1.1",
-        "@0x/contracts-asset-proxy": "^2.2.0",
-        "@0x/contracts-erc20": "^2.2.6",
+        "@0x/base-contract": "^5.3.1",
+        "@0x/contracts-asset-proxy": "^2.2.5",
+        "@0x/contracts-erc20": "^2.2.11",
         "@0x/contracts-utils": "2.0.1",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
-        "ethereum-types": "^2.1.3",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
+        "ethereum-types": "^2.1.4",
         "lodash": "^4.17.11"
     },
     "publishConfig": {

contracts/multisig/test/asset_proxy_owner.ts

@@ -61,17 +61,20 @@ describe('AssetProxyOwner', () => {
             proxyArtifacts.MixinAuthorizable,
             provider,
             txDefaults,
+            artifacts,
         );
         erc721Proxy = await MixinAuthorizableContract.deployFrom0xArtifactAsync(
             proxyArtifacts.MixinAuthorizable,
             provider,
             txDefaults,
+            artifacts,
         );
         const defaultAssetProxyContractAddresses: string[] = [];
         testAssetProxyOwner = await TestAssetProxyOwnerContract.deployFrom0xArtifactAsync(
             artifacts.TestAssetProxyOwner,
             provider,
             txDefaults,
+            artifacts,
             owners,
             defaultAssetProxyContractAddresses,
             REQUIRED_APPROVALS,
@@ -105,6 +108,7 @@ describe('AssetProxyOwner', () => {
                 artifacts.AssetProxyOwner,
                 provider,
                 txDefaults,
+                artifacts,
                 owners,
                 assetProxyContractAddresses,
                 REQUIRED_APPROVALS,
@@ -122,6 +126,7 @@ describe('AssetProxyOwner', () => {
                     artifacts.AssetProxyOwner,
                     provider,
                     txDefaults,
+                    artifacts,
                     owners,
                     assetProxyContractAddresses,
                     REQUIRED_APPROVALS,

contracts/multisig/test/multi_sig_with_time_lock.ts

@@ -66,6 +66,7 @@ describe('MultiSigWalletWithTimeLock', () => {
                 artifacts.MultiSigWalletWithTimeLock,
                 provider,
                 txDefaults,
+                artifacts,
                 owners,
                 REQUIRED_APPROVALS,
                 secondsTimeLocked,
@@ -81,6 +82,7 @@ describe('MultiSigWalletWithTimeLock', () => {
                 artifacts.MultiSigWalletWithTimeLock,
                 provider,
                 txDefaults,
+                artifacts,
                 owners,
                 REQUIRED_APPROVALS,
                 secondsTimeLocked,
@@ -135,6 +137,7 @@ describe('MultiSigWalletWithTimeLock', () => {
                 artifacts.MultiSigWalletWithTimeLock,
                 provider,
                 txDefaults,
+                artifacts,
                 owners,
                 REQUIRED_APPROVALS,
                 secondsTimeLocked,
@@ -198,6 +201,7 @@ describe('MultiSigWalletWithTimeLock', () => {
                 artifacts.TestRejectEther,
                 provider,
                 txDefaults,
+                artifacts,
             );
             const data = constants.NULL_BYTES;
             const value = new BigNumber(10);
@@ -234,6 +238,7 @@ describe('MultiSigWalletWithTimeLock', () => {
                     artifacts.MultiSigWalletWithTimeLock,
                     provider,
                     txDefaults,
+                    artifacts,
                     owners,
                     REQUIRED_APPROVALS,
                     secondsTimeLocked,
@@ -308,6 +313,7 @@ describe('MultiSigWalletWithTimeLock', () => {
                     artifacts.MultiSigWalletWithTimeLock,
                     provider,
                     txDefaults,
+                    artifacts,
                     owners,
                     REQUIRED_APPROVALS,
                     SECONDS_TIME_LOCKED,

contracts/multisig/test/utils/asset_proxy_owner_wrapper.ts

@@ -4,14 +4,17 @@ import { BigNumber } from '@0x/utils';
 import { Web3Wrapper } from '@0x/web3-wrapper';
 import { TransactionReceiptWithDecodedLogs } from 'ethereum-types';
 
-import { AssetProxyOwnerContract } from '../../generated-wrappers/asset_proxy_owner';
+import { AssetProxyOwnerContract, TestAssetProxyOwnerContract } from '../../src';
 import { artifacts } from '../../src/artifacts';
 
 export class AssetProxyOwnerWrapper {
-    private readonly _assetProxyOwner: AssetProxyOwnerContract;
+    private readonly _assetProxyOwner: AssetProxyOwnerContract | TestAssetProxyOwnerContract;
     private readonly _web3Wrapper: Web3Wrapper;
     private readonly _logDecoder: LogDecoder;
-    constructor(assetproxyOwnerContract: AssetProxyOwnerContract, provider: Web3ProviderEngine) {
+    constructor(
+        assetproxyOwnerContract: AssetProxyOwnerContract | TestAssetProxyOwnerContract,
+        provider: Web3ProviderEngine,
+    ) {
         this._assetProxyOwner = assetproxyOwnerContract;
         this._web3Wrapper = new Web3Wrapper(provider);
         this._logDecoder = new LogDecoder(this._web3Wrapper, { ...artifacts, ...proxyArtifacts });
@@ -57,7 +60,7 @@ export class AssetProxyOwnerWrapper {
     ): Promise<TransactionReceiptWithDecodedLogs> {
         // tslint:disable-next-line:no-unnecessary-type-assertion
         const txHash = await (this
-            ._assetProxyOwner as AssetProxyOwnerContract).executeRemoveAuthorizedAddressAtIndex.sendTransactionAsync(
+            ._assetProxyOwner as TestAssetProxyOwnerContract).executeRemoveAuthorizedAddressAtIndex.sendTransactionAsync(
             txId,
             {
                 from,

contracts/multisig/test/utils/multi_sig_wrapper.ts

@@ -3,14 +3,17 @@ import { BigNumber } from '@0x/utils';
 import { Web3Wrapper } from '@0x/web3-wrapper';
 import { TransactionReceiptWithDecodedLogs } from 'ethereum-types';
 
-import { MultiSigWalletContract } from '../../generated-wrappers/multi_sig_wallet';
+import { MultiSigWalletContract, MultiSigWalletWithTimeLockContract } from '../../src';
 import { artifacts } from '../../src/artifacts';
 
 export class MultiSigWrapper {
-    private readonly _multiSig: MultiSigWalletContract;
+    private readonly _multiSig: MultiSigWalletContract | MultiSigWalletWithTimeLockContract;
     private readonly _web3Wrapper: Web3Wrapper;
     private readonly _logDecoder: LogDecoder;
-    constructor(multiSigContract: MultiSigWalletContract, provider: Web3ProviderEngine) {
+    constructor(
+        multiSigContract: MultiSigWalletContract | MultiSigWalletWithTimeLockContract,
+        provider: Web3ProviderEngine,
+    ) {
         this._multiSig = multiSigContract;
         this._web3Wrapper = new Web3Wrapper(provider);
         this._logDecoder = new LogDecoder(this._web3Wrapper, artifacts);

contracts/test-utils/CHANGELOG.json

@@ -1,4 +1,49 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "3.1.13",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1564604963,
+        "version": "3.1.12",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "3.1.11",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "3.1.10",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "3.1.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "version": "3.1.8",
         "changes": [

contracts/test-utils/CHANGELOG.md

@@ -5,6 +5,26 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v3.1.13 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v3.1.12 - _July 31, 2019_
+
+    * Dependencies updated
+
+## v3.1.11 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v3.1.10 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v3.1.9 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v3.1.8 - _July 13, 2019_
 
     * Fixed false positives in `expectTransactionFailedAsync` and `expectContractCallFailedAsync` (#1852)

contracts/test-utils/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-test-utils",
-    "version": "3.1.8",
+    "version": "3.1.13",
     "engines": {
         "node": ">=6.12"
     },
@@ -34,25 +34,26 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/test-utils/README.md",
     "devDependencies": {
-        "mocha": "^4.1.0",
+        "@types/mocha": "^5.2.7",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "tslint": "5.11.0",
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/order-utils": "^8.2.0",
-        "@0x/sol-compiler": "^3.1.9",
-        "@0x/sol-coverage": "^3.0.6",
-        "@0x/sol-profiler": "^3.1.8",
-        "@0x/sol-trace": "^2.0.14",
-        "@0x/subproviders": "^4.1.1",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/order-utils": "^8.2.5",
+        "@0x/sol-compiler": "^3.1.12",
+        "@0x/sol-coverage": "^3.0.9",
+        "@0x/sol-profiler": "^3.1.11",
+        "@0x/sol-trace": "^2.0.17",
+        "@0x/subproviders": "^5.0.1",
         "@0x/tslint-config": "^3.0.1",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
         "@types/bn.js": "^4.11.0",
         "@types/js-combinatorics": "^0.5.29",
         "@types/lodash": "4.14.104",
@@ -62,7 +63,7 @@
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
-        "ethereum-types": "^2.1.3",
+        "ethereum-types": "^2.1.4",
         "ethereumjs-util": "^5.1.1",
         "ethers": "~4.0.4",
         "js-combinatorics": "^0.5.3",

contracts/utils/CHANGELOG.json

@@ -1,4 +1,54 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "3.2.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "3.2.0",
+        "changes": [
+            {
+                "note": "Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies.",
+                "pr": 1995
+            },
+            {
+                "note": "Added tests for decoding log arguments when artifact dependencies are included/excluded.",
+                "pr": 1995
+            }
+        ],
+        "timestamp": 1564604963
+    },
+    {
+        "timestamp": 1563957393,
+        "version": "3.1.10",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "3.1.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "3.1.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1563006338,
         "version": "3.1.7",

contracts/utils/CHANGELOG.md

@@ -5,6 +5,27 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v3.2.1 - _August 8, 2019_
+
+    * Dependencies updated
+
+## v3.2.0 - _July 31, 2019_
+
+    * Updated calls to <contract wrapper>.deployFrom0xArtifactAsync to include artifact dependencies. (#1995)
+    * Added tests for decoding log arguments when artifact dependencies are included/excluded. (#1995)
+
+## v3.1.10 - _July 24, 2019_
+
+    * Dependencies updated
+
+## v3.1.9 - _July 15, 2019_
+
+    * Dependencies updated
+
+## v3.1.8 - _July 13, 2019_
+
+    * Dependencies updated
+
 ## v3.1.7 - _July 13, 2019_
 
     * Dependencies updated

contracts/utils/compiler.json

@@ -32,6 +32,8 @@
         "src/interfaces/IOwnable.sol",
         "test/TestConstants.sol",
         "test/TestLibAddressArray.sol",
-        "test/TestLibBytes.sol"
+        "test/TestLibBytes.sol",
+        "test/TestLogDecoding.sol",
+        "test/TestLogDecodingDownstream.sol"
     ]
 }

contracts/utils/contracts/test/TestLogDecoding.sol

@@ -0,0 +1,55 @@
+/*
+
+  Copyright 2018 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.5;
+
+import "./TestLogDecodingDownstream.sol";
+
+
+contract TestLogDecoding {
+
+    /// @dev arbitrary event; fields to not matter.
+    event TestEvent(
+        uint256 foo,
+        bytes bar,
+        string car
+    );
+
+    /// @dev Emits a local event
+    function emitEvent()
+        public
+    {
+        emit TestEvent(256, hex'1234', "4321");
+    }
+
+    /// @dev Emits an event in a downstream contract
+    function emitEventDownstream()
+        public
+    {
+        TestLogDecodingDownstream testLogDecodingDownstream = new TestLogDecodingDownstream();
+        ITestLogDecodingDownstream(testLogDecodingDownstream).emitEvent();
+    }
+
+    /// @dev Emits a local event and a downstream event
+    function emitEventsLocalAndDownstream()
+        public
+    {
+        emitEvent();
+        emitEventDownstream();
+    }
+}

contracts/utils/contracts/test/TestLogDecodingDownstream.sol

@@ -0,0 +1,48 @@
+/*
+
+  Copyright 2018 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.5.5;
+
+
+contract ITestLogDecodingDownstream {
+
+    /// @dev Emits a local event
+    function emitEvent() external;
+}
+
+
+contract TestLogDecodingDownstream is
+    ITestLogDecodingDownstream
+{
+
+    /// @dev event with fields different than those in `TestLogDecoding.TestEvent`
+    /// Note: do not include this in the interface
+    /// For testing, we want to emit an event that is
+    /// not known by the calling contract.
+    event TestEvent2(
+        uint256 lorem,
+        string ipsum
+    );
+
+    /// @dev Emits a local event
+    function emitEvent()
+        external
+    {
+        emit TestEvent2(256, "4321");
+    }
+}

contracts/utils/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-utils",
-    "version": "3.1.7",
+    "version": "3.2.1",
     "engines": {
         "node": ">=6.12"
     },
@@ -34,7 +34,7 @@
         "lint-contracts": "solhint -c ../.solhint.json contracts/**/**/**/**/*.sol"
     },
     "config": {
-        "abis": "./generated-artifacts/@(Address|IOwnable|LibBytes|Ownable|ReentrancyGuard|SafeMath|TestConstants|TestLibAddressArray|TestLibBytes).json",
+        "abis": "./generated-artifacts/@(Address|IOwnable|LibBytes|Ownable|ReentrancyGuard|SafeMath|TestConstants|TestLibAddressArray|TestLibBytes|TestLogDecoding|TestLogDecodingDownstream).json",
         "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually."
     },
     "repository": {
@@ -47,21 +47,22 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/utils/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^2.1.0",
-        "@0x/contracts-gen": "^1.0.10",
-        "@0x/contracts-test-utils": "^3.1.8",
-        "@0x/dev-utils": "^2.2.4",
-        "@0x/sol-compiler": "^3.1.9",
+        "@0x/abi-gen": "^4.1.0",
+        "@0x/contracts-gen": "^1.0.13",
+        "@0x/contracts-test-utils": "^3.1.13",
+        "@0x/dev-utils": "^2.3.0",
+        "@0x/sol-compiler": "^3.1.12",
         "@0x/tslint-config": "^3.0.1",
         "@types/bn.js": "^4.11.0",
         "@types/lodash": "4.14.104",
+        "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
         "make-promises-safe": "^1.1.0",
-        "mocha": "^4.1.0",
+        "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "solhint": "^1.4.1",
@@ -69,14 +70,14 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^5.1.1",
-        "@0x/order-utils": "^8.2.0",
-        "@0x/types": "^2.4.0",
-        "@0x/typescript-typings": "^4.2.3",
-        "@0x/utils": "^4.4.0",
-        "@0x/web3-wrapper": "^6.0.7",
+        "@0x/base-contract": "^5.3.1",
+        "@0x/order-utils": "^8.2.5",
+        "@0x/types": "^2.4.1",
+        "@0x/typescript-typings": "^4.2.4",
+        "@0x/utils": "^4.5.0",
+        "@0x/web3-wrapper": "^6.0.10",
         "bn.js": "^4.11.8",
-        "ethereum-types": "^2.1.3",
+        "ethereum-types": "^2.1.4",
         "ethereumjs-util": "^5.1.1",
         "lodash": "^4.17.11"
     },

contracts/utils/src/artifacts.ts

@@ -14,6 +14,8 @@ import * as SafeMath from '../generated-artifacts/SafeMath.json';
 import * as TestConstants from '../generated-artifacts/TestConstants.json';
 import * as TestLibAddressArray from '../generated-artifacts/TestLibAddressArray.json';
 import * as TestLibBytes from '../generated-artifacts/TestLibBytes.json';
+import * as TestLogDecoding from '../generated-artifacts/TestLogDecoding.json';
+import * as TestLogDecodingDownstream from '../generated-artifacts/TestLogDecodingDownstream.json';
 export const artifacts = {
     Address: Address as ContractArtifact,
     LibBytes: LibBytes as ContractArtifact,
@@ -22,6 +24,8 @@ export const artifacts = {
     SafeMath: SafeMath as ContractArtifact,
     IOwnable: IOwnable as ContractArtifact,
     TestConstants: TestConstants as ContractArtifact,
-    TestLibBytes: TestLibBytes as ContractArtifact,
     TestLibAddressArray: TestLibAddressArray as ContractArtifact,
+    TestLibBytes: TestLibBytes as ContractArtifact,
+    TestLogDecoding: TestLogDecoding as ContractArtifact,
+    TestLogDecodingDownstream: TestLogDecodingDownstream as ContractArtifact,
 };

contracts/utils/src/wrappers.ts

@@ -12,3 +12,5 @@ export * from '../generated-wrappers/safe_math';
 export * from '../generated-wrappers/test_constants';
 export * from '../generated-wrappers/test_lib_address_array';
 export * from '../generated-wrappers/test_lib_bytes';
+export * from '../generated-wrappers/test_log_decoding';
+export * from '../generated-wrappers/test_log_decoding_downstream';

contracts/utils/test/lib_address_array.ts

@@ -28,6 +28,7 @@ describe('LibAddressArray', () => {
             artifacts.TestLibAddressArray,
             provider,
             txDefaults,
+            artifacts,
         );
     });
     after(async () => {

contracts/utils/test/lib_bytes.ts

@@ -68,7 +68,12 @@ describe('LibBytes', () => {
         testAddress = accounts[1];
         testAddressB = accounts[2];
         // Deploy LibBytes
-        libBytes = await TestLibBytesContract.deployFrom0xArtifactAsync(artifacts.TestLibBytes, provider, txDefaults);
+        libBytes = await TestLibBytesContract.deployFrom0xArtifactAsync(
+            artifacts.TestLibBytes,
+            provider,
+            txDefaults,
+            artifacts,
+        );
         // Verify lengths of test data
         const byteArrayShorterThan32BytesLength = ethUtil.toBuffer(byteArrayShorterThan32Bytes).byteLength;
         expect(byteArrayShorterThan32BytesLength).to.be.lessThan(32);

contracts/utils/test/libs.ts

@@ -24,6 +24,7 @@ describe('Libs', () => {
                     artifacts.TestConstants,
                     provider,
                     txDefaults,
+                    artifacts,
                 );
                 const isValid = await testConstants.assertValidZrxAssetData.callAsync();
                 expect(isValid).to.be.equal(true);

contracts/utils/test/log_decoding.ts

@@ -0,0 +1,95 @@
+import { chaiSetup, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
+import { BlockchainLifecycle } from '@0x/dev-utils';
+import { BigNumber } from '@0x/utils';
+import * as chai from 'chai';
+import { DecodedLogArgs, LogWithDecodedArgs } from 'ethereum-types';
+
+import { artifacts, TestLogDecodingContract } from '../src';
+
+chaiSetup.configure();
+const expect = chai.expect;
+
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+describe('TestLogDecoding', () => {
+    let testLogDecodingWithDependencies: TestLogDecodingContract;
+    let testLogDecodingDeployedWithoutDependencies: TestLogDecodingContract;
+    const expectedEvent = {
+        foo: new BigNumber(256),
+        bar: '0x1234',
+        car: '4321',
+    };
+    const expectedDownstreamEvent = {
+        lorem: new BigNumber(256),
+        ipsum: '4321',
+    };
+    const emptyDependencyList = {};
+
+    before(async () => {
+        testLogDecodingDeployedWithoutDependencies = await TestLogDecodingContract.deployFrom0xArtifactAsync(
+            artifacts.TestLogDecoding,
+            provider,
+            txDefaults,
+            emptyDependencyList,
+        );
+        testLogDecodingWithDependencies = await TestLogDecodingContract.deployFrom0xArtifactAsync(
+            artifacts.TestLogDecoding,
+            provider,
+            txDefaults,
+            artifacts,
+        );
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    describe('Decoding Log Arguments', () => {
+        it('should decode locally emitted event args when no dependencies are passed into wrapper', async () => {
+            const txReceipt = await testLogDecodingDeployedWithoutDependencies.emitEvent.awaitTransactionSuccessAsync();
+            expect(txReceipt.logs.length).to.be.equal(1);
+            // tslint:disable no-unnecessary-type-assertion
+            expect((txReceipt.logs[0] as LogWithDecodedArgs<DecodedLogArgs>).args).to.be.deep.equal(expectedEvent);
+        });
+        it('should not decode event args when no dependencies are passed into wrapper', async () => {
+            const txReceipt = await testLogDecodingDeployedWithoutDependencies.emitEventDownstream.awaitTransactionSuccessAsync();
+            expect(txReceipt.logs.length).to.be.equal(1);
+            // tslint:disable no-unnecessary-type-assertion
+            expect((txReceipt.logs[0] as LogWithDecodedArgs<DecodedLogArgs>).args).to.be.undefined();
+        });
+        it('should decode args for local but not downstream event when no dependencies are passed into wrapper', async () => {
+            const txReceipt = await testLogDecodingDeployedWithoutDependencies.emitEventsLocalAndDownstream.awaitTransactionSuccessAsync();
+            expect(txReceipt.logs.length).to.be.equal(2);
+            // tslint:disable no-unnecessary-type-assertion
+            expect((txReceipt.logs[0] as LogWithDecodedArgs<DecodedLogArgs>).args).to.be.deep.equal(expectedEvent);
+            // tslint:disable no-unnecessary-type-assertion
+            expect((txReceipt.logs[1] as LogWithDecodedArgs<DecodedLogArgs>).args).to.be.undefined();
+        });
+        it('should decode locally emitted event args when dependencies are passed into wrapper', async () => {
+            const txReceipt = await testLogDecodingWithDependencies.emitEvent.awaitTransactionSuccessAsync();
+            expect(txReceipt.logs.length).to.be.equal(1);
+            // tslint:disable no-unnecessary-type-assertion
+            expect((txReceipt.logs[0] as LogWithDecodedArgs<DecodedLogArgs>).args).to.be.deep.equal(expectedEvent);
+        });
+        it('should decode downstream event args when dependencies are passed into wrapper', async () => {
+            const txReceipt = await testLogDecodingWithDependencies.emitEventDownstream.awaitTransactionSuccessAsync();
+            expect(txReceipt.logs.length).to.be.equal(1);
+            // tslint:disable no-unnecessary-type-assertion
+            expect((txReceipt.logs[0] as LogWithDecodedArgs<DecodedLogArgs>).args).to.be.deep.equal(
+                expectedDownstreamEvent,
+            );
+        });
+        it('should decode args for both local and downstream events when dependencies are passed into wrapper', async () => {
+            const txReceipt = await testLogDecodingWithDependencies.emitEventsLocalAndDownstream.awaitTransactionSuccessAsync();
+            expect(txReceipt.logs.length).to.be.equal(2);
+            // tslint:disable no-unnecessary-type-assertion
+            expect((txReceipt.logs[0] as LogWithDecodedArgs<DecodedLogArgs>).args).to.be.deep.equal(expectedEvent);
+            // tslint:disable no-unnecessary-type-assertion
+            expect((txReceipt.logs[1] as LogWithDecodedArgs<DecodedLogArgs>).args).to.be.deep.equal(
+                expectedDownstreamEvent,
+            );
+        });
+    });
+});

contracts/utils/tsconfig.json

@@ -11,7 +11,9 @@
         "generated-artifacts/SafeMath.json",
         "generated-artifacts/TestConstants.json",
         "generated-artifacts/TestLibAddressArray.json",
-        "generated-artifacts/TestLibBytes.json"
+        "generated-artifacts/TestLibBytes.json",
+        "generated-artifacts/TestLogDecoding.json",
+        "generated-artifacts/TestLogDecodingDownstream.json"
     ],
     "exclude": ["./deploy/solc/solc_bin"]
 }

package.json

@@ -50,7 +50,7 @@
     "config": {
         "contractsPackages": "@0x/contracts-asset-proxy @0x/contracts-erc20 @0x/contracts-erc721 @0x/contracts-erc1155 @0x/contracts-exchange @0x/contracts-exchange-forwarder @0x/contracts-exchange-libs @0x/contracts-extensions @0x/contracts-multisig @0x/contracts-test-utils @0x/contracts-utils @0x/contracts-coordinator @0x/contracts-dev-utils",
         "mnemonic": "concert load couple harbor equip island argue ramp clarify fence smart topic",
-        "packagesWithDocPages": "0x.js connect json-schemas subproviders web3-wrapper contract-wrappers order-utils order-watcher sol-compiler sol-coverage sol-profiler sol-trace ethereum-types asset-buyer migrations",
+        "packagesWithDocPages": "0x.js connect json-schemas subproviders web3-wrapper order-utils order-watcher sol-compiler sol-coverage sol-profiler sol-trace ethereum-types asset-buyer migrations",
         "ignoreDependencyVersions": "@types/styled-components @types/node",
         "ignoreDependencyVersionsForPackage": "website instant dev-tools-pages"
     },
@@ -77,7 +77,7 @@
         "graceful-fs": "4.1.15"
     },
     "devDependencies": {
-        "@0x-lerna-fork/lerna": "3.0.0-beta.26",
+        "@0x-lerna-fork/lerna": "3.16.10",
         "@0xproject/npm-cli-login": "^0.0.11",
         "async-child-process": "^1.1.1",
         "bundlewatch": "^0.2.1",

packages/0x.js/CHANGELOG.json

@@ -1,4 +1,50 @@
 [
+    {
+        "timestamp": 1565296576,
+        "version": "6.0.15",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1564604963,
+        "version": "6.0.14",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "6.0.13",
+        "changes": [
+            {
+                "note": "re-export new ethereum-types type, TupleDataItem",
+                "pr": 1919
+            }
+        ],
+        "timestamp": 1563957393
+    },
+    {
+        "timestamp": 1563193019,
+        "version": "6.0.12",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1563047529,
+        "version": "6.0.11",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1563006338,
         "version": "6.0.10",