Updated CHANGELOGS

Add more tslint rules

.circleci/config.yml

@@ -22,7 +22,7 @@ jobs:
       - run: wget https://s3.amazonaws.com/testrpc-shapshots/${CONTRACTS_COMMIT_HASH}.zip
       - run: unzip ${CONTRACTS_COMMIT_HASH}.zip -d testrpc_snapshot
       - run: node ./node_modules/lerna/bin/lerna.js bootstrap
-      - run: yarn lerna:run build
+      - run: yarn build
       - save_cache:
           key: repo-{{ .Environment.CIRCLE_SHA1 }}
           paths:
@@ -48,7 +48,7 @@ jobs:
           name: testrpc
           command: npm run testrpc -- --db testrpc_snapshot
           background: true
-      - run: yarn lerna:run --scope 0x.js test:circleci
+      - run: yarn wsrun test:circleci 0x.js
       - save_cache:
           key: coverage-0xjs-{{ .Environment.CIRCLE_SHA1 }}
           paths:
@@ -65,12 +65,12 @@ jobs:
           name: testrpc
           command: npm run testrpc -- --db testrpc_snapshot
           background: true
-      - run: yarn lerna:run --scope contracts test:circleci
+      - run: yarn wsrun test:circleci contracts
       - save_cache:
           key: coverage-contracts-{{ .Environment.CIRCLE_SHA1 }}
           paths:
             - ~/repo/packages/contracts/coverage/lcov.info
-  test-deployer:
+  test-sol-compiler:
     docker:
       - image: circleci/node:6.12
     working_directory: ~/repo
@@ -82,11 +82,11 @@ jobs:
           name: testrpc
           command: npm run testrpc -- --db testrpc_snapshot
           background: true
-      - run: yarn lerna:run --scope @0xproject/deployer test:circleci
+      - run: yarn wsrun test:circleci @0xproject/sol-compiler
       - save_cache:
-          key: coverage-deployer-{{ .Environment.CIRCLE_SHA1 }}
+          key: coverage-sol-compiler-{{ .Environment.CIRCLE_SHA1 }}
           paths:
-            - ~/repo/packages/deployer/coverage/lcov.info
+            - ~/repo/packages/sol-compiler/coverage/lcov.info
   test-rest:
     docker:
       - image: circleci/node:6.12
@@ -99,7 +99,7 @@ jobs:
           name: testrpc
           command: npm run testrpc -- --db testrpc_snapshot
           background: true
-      - run: yarn lerna:run --ignore contracts --ignore 0x.js --ignore @0xproject/deployer test:circleci
+      - run: yarn wsrun test:circleci --exclude contracts --exclude 0x.js --exclude @0xproject/sol-compiler --stages --exclude-missing
       - save_cache:
           key: coverage-assert-{{ .Environment.CIRCLE_SHA1 }}
           paths:
@@ -177,7 +177,7 @@ jobs:
             - coverage-sol-cov-{{ .Environment.CIRCLE_SHA1 }}
       - restore_cache:
           keys:
-            - coverage-deployer-{{ .Environment.CIRCLE_SHA1 }}
+            - coverage-sol-compiler-{{ .Environment.CIRCLE_SHA1 }}
       - restore_cache:
           keys:
             - coverage-0xjs-{{ .Environment.CIRCLE_SHA1 }}
@@ -199,7 +199,7 @@ workflows:
       - test-contracts:
           requires:
             - build
-      - test-deployer:
+      - test-sol-compiler:
           requires:
             - build
       - test-rest:
@@ -214,6 +214,6 @@ workflows:
       - submit-coverage:
           requires:
             - test-0xjs
-            - test-deployer
+            - test-sol-compiler
             - test-rest
             - test-contracts

.gitignore

@@ -70,22 +70,26 @@ TODO.md
 packages/website/public/bundle*
 packages/react-docs/example/public/bundle*
 
-# generated binaries
-bin/
+# server cli
+packages/testnet-faucets/server/
 
-# generated contract artifacts
-packages/sol-cov/test/fixtures/artifacts
-packages/metacoin/artifacts
-packages/0x.js/test/artifacts
-packages/migrations/src/artifacts
+# generated contract artifacts/
+packages/sol-cov/test/fixtures/artifacts/
+packages/metacoin/artifacts/
+packages/order-watcher/test/artifacts/
+packages/contract-wrappers/test/artifacts/
 
 # generated contract wrappers
 packages/0x.js/src/contract_wrappers/generated/
 packages/contracts/src/contract_wrappers/generated/
+packages/contract-wrappers/src/contract_wrappers/generated/
 packages/metacoin/src/contract_wrappers
+packages/fill-scenarios/src/generated_contract_wrappers/
+packages/order-watcher/src/generated_contract_wrappers/
+packages/migrations/src/contract_wrappers
 
-# solc-bin in deployer
-packages/deployer/solc_bin/
+# solc-bin in sol-compiler
+packages/sol-compiler/solc_bin/
 
 # Monorepo scripts
 packages/*/scripts/

.prettierignore

@@ -1,7 +1,10 @@
 lib
 .nyc_output
+/packages/0x.js/test/artifacts
 /packages/contracts/src/artifacts
 /packages/metacoin/artifacts
-/packages/migrations/src/artifacts
+/packages/contract-wrappers/test/artifacts
+/packages/order-watcher/test/artifacts
+/packages/migrations/artifacts/1.0.0
 package.json
 scripts/postpublish_utils.js

CODEOWNERS

@@ -1 +0,0 @@
-*        @abandeali1 @BMillman19 @dekz @fabioberger @LogvinovLeon @Recmo

CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+*   Using welcoming and inclusive language
+*   Being respectful of differing viewpoints and experiences
+*   Gracefully accepting constructive criticism
+*   Focusing on what is best for the community
+*   Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+*   The use of sexualized language or imagery and unwelcome sexual attention or advances
+*   Trolling, insulting/derogatory comments, and personal or political attacks
+*   Public or private harassment
+*   Publishing others' private information, such as a physical or electronic address, without explicit permission
+*   Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at team@0xproject.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

README.md

@@ -17,27 +17,27 @@ This repository is a monorepo including the 0x protocol smart contracts and nume
 
 ### Published Packages
 
-| Package                                                         | Version                                                                                                                               | Description                                                                 |
-| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
-| [`0x.js`](/packages/0x.js)                                      | [![npm](https://img.shields.io/npm/v/0x.js.svg)](https://www.npmjs.com/package/0x.js)                                                 | A Javascript library for interacting with the 0x protocol                   |
-| [`@0xproject/abi-gen`](/packages/abi-gen)                       | [![npm](https://img.shields.io/npm/v/@0xproject/abi-gen.svg)](https://www.npmjs.com/package/@0xproject/abi-gen)                       | Tool to generate TS wrappers from smart contract ABIs                       |
-| [`@0xproject/assert`](/packages/assert)                         | [![npm](https://img.shields.io/npm/v/@0xproject/assert.svg)](https://www.npmjs.com/package/@0xproject/assert)                         | Type and schema assertions used by our packages                             |
-| [`@0xproject/base-contract`](/packages/base-contract)           | [![npm](https://img.shields.io/npm/v/@0xproject/base-contract.svg)](https://www.npmjs.com/package/@0xproject/base-contract)           | BaseContract used by auto-generated `abi-gen` wrapper contracts             |
-| [`@0xproject/connect`](/packages/connect)                       | [![npm](https://img.shields.io/npm/v/@0xproject/connect.svg)](https://www.npmjs.com/package/@0xproject/connect)                       | A Javascript library for interacting with the Standard Relayer API          |
-| [`@0xproject/deployer`](/packages/deployer)                     | [![npm](https://img.shields.io/npm/v/@0xproject/deployer.svg)](https://www.npmjs.com/package/@0xproject/deployer)                     | Solidity project compiler and deployer framework                            |
-| [`@0xproject/dev-utils`](/packages/dev-utils)                   | [![npm](https://img.shields.io/npm/v/@0xproject/dev-utils.svg)](https://www.npmjs.com/package/@0xproject/dev-utils)                   | Dev utils to be shared across 0x projects and packages                      |
-| [`@0xproject/json-schemas`](/packages/json-schemas)             | [![npm](https://img.shields.io/npm/v/@0xproject/json-schemas.svg)](https://www.npmjs.com/package/@0xproject/json-schemas)             | 0x-related json schemas                                                     |
-| [`@0xproject/monorepo-scripts`](/packages/monorepo-scripts)     | [![npm](https://img.shields.io/npm/v/@0xproject/monorepo-scripts.svg)](https://www.npmjs.com/package/@0xproject/monorepo-scripts)     | Monorepo scripts                                                            |
-| [`@0xproject/react-docs`](/packages/react-docs)                 | [![npm](https://img.shields.io/npm/v/@0xproject/react-docs.svg)](https://www.npmjs.com/package/@0xproject/react-docs)                 | React documentation component for rendering TypeDoc & Doxity generated JSON |
-| [`@0xproject/react-shared`](/packages/react-shared)             | [![npm](https://img.shields.io/npm/v/@0xproject/react-shared.svg)](https://www.npmjs.com/package/@0xproject/react-shared)             | 0x shared react components                                                  |
-| [`@0xproject/sra-report`](/packages/sra-report)                 | [![npm](https://img.shields.io/npm/v/@0xproject/sra-report.svg)](https://www.npmjs.com/package/@0xproject/sra-report)                 | Generate reports for standard relayer API compliance                        |
-| [`@0xproject/sol-cov`](/packages/sol-cov)                       | [![npm](https://img.shields.io/npm/v/@0xproject/sol-cov.svg)](https://www.npmjs.com/package/@0xproject/sol-cov)                       | Solidity test coverage tool                                                 |
-| [`@0xproject/subproviders`](/packages/subproviders)             | [![npm](https://img.shields.io/npm/v/@0xproject/subproviders.svg)](https://www.npmjs.com/package/@0xproject/subproviders)             | Useful web3 subproviders (e.g LedgerSubprovider)                            |
-| [`@0xproject/tslint-config`](/packages/tslint-config)           | [![npm](https://img.shields.io/npm/v/@0xproject/tslint-config.svg)](https://www.npmjs.com/package/@0xproject/tslint-config)           | Custom 0x development TSLint rules                                          |
-| [`@0xproject/types`](/packages/types)                           | [![npm](https://img.shields.io/npm/v/@0xproject/types.svg)](https://www.npmjs.com/package/@0xproject/types)                           | Shared type declarations                                                    |
-| [`@0xproject/typescript-typings`](/packages/typescript-typings) | [![npm](https://img.shields.io/npm/v/@0xproject/typescript-typings.svg)](https://www.npmjs.com/package/@0xproject/typescript-typings) | Repository of types for external packages                                   |
-| [`@0xproject/utils`](/packages/utils)                           | [![npm](https://img.shields.io/npm/v/@0xproject/utils.svg)](https://www.npmjs.com/package/@0xproject/utils)                           | Shared utilities                                                            |
-| [`@0xproject/web3-wrapper`](/packages/web3-wrapper)             | [![npm](https://img.shields.io/npm/v/@0xproject/web3-wrapper.svg)](https://www.npmjs.com/package/@0xproject/web3-wrapper)             | Web3 wrapper                                                                |
+| Package                                                         | Version                                                                                                                               | Description                                                                                                               |
+| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| [`0x.js`](/packages/0x.js)                                      | [![npm](https://img.shields.io/npm/v/0x.js.svg)](https://www.npmjs.com/package/0x.js)                                                 | A Javascript library for interacting with the 0x protocol                                                                 |
+| [`@0xproject/abi-gen`](/packages/abi-gen)                       | [![npm](https://img.shields.io/npm/v/@0xproject/abi-gen.svg)](https://www.npmjs.com/package/@0xproject/abi-gen)                       | Tool to generate TS wrappers from smart contract ABIs                                                                     |
+| [`@0xproject/assert`](/packages/assert)                         | [![npm](https://img.shields.io/npm/v/@0xproject/assert.svg)](https://www.npmjs.com/package/@0xproject/assert)                         | Type and schema assertions used by our packages                                                                           |
+| [`@0xproject/base-contract`](/packages/base-contract)           | [![npm](https://img.shields.io/npm/v/@0xproject/base-contract.svg)](https://www.npmjs.com/package/@0xproject/base-contract)           | BaseContract used by auto-generated `abi-gen` wrapper contracts                                                           |
+| [`@0xproject/connect`](/packages/connect)                       | [![npm](https://img.shields.io/npm/v/@0xproject/connect.svg)](https://www.npmjs.com/package/@0xproject/connect)                       | A Javascript library for interacting with the Standard Relayer API                                                        |
+| [`@0xproject/sol-compiler`](/packages/sol-compiler)             | [![npm](https://img.shields.io/npm/v/@0xproject/sol-compiler.svg)](https://www.npmjs.com/package/@0xproject/sol-compiler)             | A thin wrapper around Solc.js that outputs artifacts, resolves imports, only re-compiles when needed, and other niceties. |
+| [`@0xproject/dev-utils`](/packages/dev-utils)                   | [![npm](https://img.shields.io/npm/v/@0xproject/dev-utils.svg)](https://www.npmjs.com/package/@0xproject/dev-utils)                   | Dev utils to be shared across 0x projects and packages                                                                    |
+| [`@0xproject/json-schemas`](/packages/json-schemas)             | [![npm](https://img.shields.io/npm/v/@0xproject/json-schemas.svg)](https://www.npmjs.com/package/@0xproject/json-schemas)             | 0x-related json schemas                                                                                                   |
+| [`@0xproject/monorepo-scripts`](/packages/monorepo-scripts)     | [![npm](https://img.shields.io/npm/v/@0xproject/monorepo-scripts.svg)](https://www.npmjs.com/package/@0xproject/monorepo-scripts)     | Monorepo scripts                                                                                                          |
+| [`@0xproject/react-docs`](/packages/react-docs)                 | [![npm](https://img.shields.io/npm/v/@0xproject/react-docs.svg)](https://www.npmjs.com/package/@0xproject/react-docs)                 | React documentation component for rendering TypeDoc & Doxity generated JSON                                               |
+| [`@0xproject/react-shared`](/packages/react-shared)             | [![npm](https://img.shields.io/npm/v/@0xproject/react-shared.svg)](https://www.npmjs.com/package/@0xproject/react-shared)             | 0x shared react components                                                                                                |
+| [`@0xproject/sra-report`](/packages/sra-report)                 | [![npm](https://img.shields.io/npm/v/@0xproject/sra-report.svg)](https://www.npmjs.com/package/@0xproject/sra-report)                 | Generate reports for standard relayer API compliance                                                                      |
+| [`@0xproject/sol-cov`](/packages/sol-cov)                       | [![npm](https://img.shields.io/npm/v/@0xproject/sol-cov.svg)](https://www.npmjs.com/package/@0xproject/sol-cov)                       | Solidity test coverage tool                                                                                               |
+| [`@0xproject/subproviders`](/packages/subproviders)             | [![npm](https://img.shields.io/npm/v/@0xproject/subproviders.svg)](https://www.npmjs.com/package/@0xproject/subproviders)             | Useful web3 subproviders (e.g LedgerSubprovider)                                                                          |
+| [`@0xproject/tslint-config`](/packages/tslint-config)           | [![npm](https://img.shields.io/npm/v/@0xproject/tslint-config.svg)](https://www.npmjs.com/package/@0xproject/tslint-config)           | Custom 0x development TSLint rules                                                                                        |
+| [`@0xproject/types`](/packages/types)                           | [![npm](https://img.shields.io/npm/v/@0xproject/types.svg)](https://www.npmjs.com/package/@0xproject/types)                           | Shared type declarations                                                                                                  |
+| [`@0xproject/typescript-typings`](/packages/typescript-typings) | [![npm](https://img.shields.io/npm/v/@0xproject/typescript-typings.svg)](https://www.npmjs.com/package/@0xproject/typescript-typings) | Repository of types for external packages                                                                                 |
+| [`@0xproject/utils`](/packages/utils)                           | [![npm](https://img.shields.io/npm/v/@0xproject/utils.svg)](https://www.npmjs.com/package/@0xproject/utils)                           | Shared utilities                                                                                                          |
+| [`@0xproject/web3-wrapper`](/packages/web3-wrapper)             | [![npm](https://img.shields.io/npm/v/@0xproject/web3-wrapper.svg)](https://www.npmjs.com/package/@0xproject/web3-wrapper)             | Web3 wrapper                                                                                                              |
 
 ### Private Packages
 
@@ -56,12 +56,14 @@ Dedicated documentation pages:
 *   [0x Connect](https://0xproject.com/docs/connect)
 *   [Smart contracts](https://0xproject.com/docs/contracts)
 *   [Subproviders](https://0xproject.com/docs/subproviders)
-*   [Deployer](https://0xproject.com/docs/deployer)
+*   [Sol Compiler](https://0xproject.com/docs/sol-compiler)
 *   [Web3-wrapper](https://0xproject.com/docs/web3-wrapper)
 *   [JSON-schemas](https://0xproject.com/docs/json-schemas)
 *   [Sol-cov](https://0xproject.com/docs/sol-cov)
 *   [Standard Relayer API](https://github.com/0xProject/standard-relayer-api/blob/master/README.md)
 
+Node version >= 6.12 is required.
+
 Most of the packages require additional typings for external dependencies.
 You can include those by prepending @0xproject/typescript-typings package to your [`typeRoots`](http://www.typescriptlang.org/docs/handbook/tsconfig-json.html) config.
 
@@ -91,32 +93,87 @@ yarn install
 
 ### Build
 
-Build all packages. You need to do this before working on any given package. Although these packages
-as independent, when run from within the monorepo, they are internally symlinked, to make development
-easier. You can change several packages and run the changes without publishing them first to NPM. When
-running `rebuild`, Lerna will figure out the dependency order of all the packages, and build them in
-this order.
+To build all packages:
 
 ```bash
-yarn lerna:rebuild
+yarn build
 ```
 
-Or continuously rebuild on change:
+To build a specific package:
 
 ```bash
-yarn dev
+PKG=@0xproject/web3-wrapper yarn build
+```
+
+### Watch
+
+To re-build all packages on change:
+
+```bash
+yarn watch
+```
+
+To watch a specific package and all it's dependent packages:
+
+```bash
+PKG=[NPM_PACKAGE_NAME] yarn watch
+
+e.g
+PKG=@0xproject/web3-wrapper yarn watch
+```
+
+### Clean
+
+Clean all packages:
+
+```bash
+yarn clean
+```
+
+Clean a specific package
+
+```bash
+PKG=0x.js yarn clean
+```
+
+### Rebuild
+
+To re-build (clean & build) all packages:
+
+```bash
+yarn rebuild
+```
+
+To re-build (clean & build) a specific package & it's deps:
+
+```bash
+PKG=0x.js yarn rebuild
 ```
 
 ### Lint
 
-Lint all packages
+Lint all packages:
 
 ```bash
-yarn lerna:run lint
+yarn lint
+```
+
+Lint a specific package:
+
+```bash
+PKG=0x.js yarn lint
 ```
 
 ### Run Tests
 
+Run all tests:
+
 ```bash
-yarn lerna:test
+yarn test
+```
+
+Run a specific package's test:
+
+```bash
+PKG=@0xproject/web3-wrapper yarn test
 ```

package.json

@@ -1,27 +1,32 @@
 {
     "private": true,
     "name": "0x-monorepo",
+    "engines": {
+        "node" : ">=6.12"
+    },
     "workspaces": [
         "packages/*"
     ],
     "scripts": {
-        "dev": "lerna run --parallel build:watch",
-        "testrpc": "testrpc -p 8545 --networkId 50 -m \"${npm_package_config_mnemonic}\"",
+        "ganache": "ganache-cli -p 8545 --networkId 50 -m \"${npm_package_config_mnemonic}\"",
         "prettier": "prettier --write '**/*.{ts,tsx,json,md}' --config .prettierrc",
         "prettier:ci": "prettier --list-different '**/*.{ts,tsx,json,md}' --config .prettierrc",
         "report_coverage": "lcov-result-merger 'packages/*/coverage/lcov.info' | coveralls",
         "test:installation": "node ./packages/monorepo-scripts/lib/test_installation.js",
-        "lerna:install": "yarn install",
-        "lerna:run": "lerna run",
-        "lerna:test": "lerna run test",
-        "lerna:clean": "lerna run clean",
-        "lerna:build": "lerna run build",
-        "lerna:rebuild": "run-s lerna:clean lerna:build",
-        "lerna:publish": "run-s lerna:install lerna:rebuild script:publish",
-        "lerna:publish:dry": "run-s lerna:install lerna:rebuild script:publish:dry",
-        "lerna:stage_docs": "lerna run docs:stage",
+        "run:publish": "run-s install:all rebuild script:publish",
+        "run:publish:dry": "run-s install:all rebuild script:publish:dry",
         "script:publish": "node ./packages/monorepo-scripts/lib/publish.js",
-        "script:publish:dry": "IS_DRY_RUN=true yarn script:publish"
+        "script:publish:dry": "IS_DRY_RUN=true yarn script:publish",
+        "install:all": "yarn install",
+        "wsrun": "wsrun",
+        "lerna:run": "lerna run",
+        "watch": "wsrun watch $PKG -r --stages --done-criteria='complete|successfully'",
+        "build": "wsrun build $PKG -r --stages",
+        "clean": "wsrun clean $PKG -r --parallel",
+        "rebuild": "run-s clean build",
+        "test": "wsrun test $PKG --serial --exclude-missing",
+        "stage_docs": "wsrun docs:stage $PKG --parallel --exclude-missing",
+        "lint": "wsrun lint $PKG --parallel --exclude-missing"
     },
     "config": {
         "mnemonic": "concert load couple harbor equip island argue ramp clarify fence smart topic"
@@ -29,10 +34,11 @@
     "devDependencies": {
         "async-child-process": "^1.1.1",
         "coveralls": "^3.0.0",
-        "ethereumjs-testrpc": "^6.0.3",
+        "ganache-cli": "^6.1.0",
         "lcov-result-merger": "^2.0.0",
         "lerna": "^2.5.1",
         "npm-run-all": "^4.1.2",
-        "prettier": "^1.11.1"
+        "prettier": "^1.11.1",
+        "wsrun": "^2.2.0"
     }
 }

packages/0x.js/CHANGELOG.json

@@ -1,4 +1,59 @@
 [
+    {
+        "version": "0.38.0",
+        "changes": [
+            {
+                "note": "Renamed createOrderStateWatcher to createOrderWatcherAsync since it is now async",
+                "pr": 579
+            },
+            {
+                "note":
+                    "Renamed ZeroExError to ContractWrappersErrors since they now lives in the @0xproject/contract-wrappers subpackage",
+                "pr": 579
+            }
+        ],
+        "timestamp": 1527008270
+    },
+    {
+        "timestamp": 1525477860,
+        "version": "0.37.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1525453812,
+        "version": "0.37.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "0.37.0",
+        "changes": [
+            {
+                "note": "Fixed expiration watcher comparator to handle orders with equal expiration times",
+                "pr": 526
+            },
+            {
+                "note": "Update Web3 Provider Engine to 14.0.4",
+                "pr": 555
+            },
+            {
+                "note": "Add `zeroEx.getProvider()`",
+                "pr": 559
+            },
+            {
+                "note": "Move `ZeroExError.InvalidSignature` to `@0xproject/order-utils` `OrderError.InvalidSignature`",
+                "pr": 559
+            }
+        ],
+        "timestamp": 1525428773
+    },
     {
         "version": "0.36.3",
         "changes": [

packages/0x.js/CHANGELOG.md

@@ -5,6 +5,26 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v0.38.0 - _May 22, 2018_
+
+    * Renamed createOrderStateWatcher to createOrderWatcherAsync since it is now async (#579)
+    * Renamed ZeroExError to ContractWrappersErrors since they now lives in the @0xproject/contract-wrappers subpackage (#579)
+
+## v0.37.2 - _May 4, 2018_
+
+    * Dependencies updated
+
+## v0.37.1 - _May 4, 2018_
+
+    * Dependencies updated
+
+## v0.37.0 - _May 4, 2018_
+
+    * Fixed expiration watcher comparator to handle orders with equal expiration times (#526)
+    * Update Web3 Provider Engine to 14.0.4 (#555)
+    * Add `zeroEx.getProvider()` (#559)
+    * Move `ZeroExError.InvalidSignature` to `@0xproject/order-utils` `OrderError.InvalidSignature` (#559)
+
 ## v0.36.3 - _April 18, 2018_
 
     * Move @0xproject/migrations to devDependencies

packages/0x.js/README.md

@@ -44,7 +44,7 @@ Download the UMD module from our [releases page](https://github.com/0xProject/0x
 
 ## Contributing
 
-We strongly recommend that the community help us make improvements and determine the future direction of the protocol. To report bugs within this package, please create an issue in this repository.
+We strongly recommend that the community help us make improvements and determine the future direction of 0x protocol. To report bugs within this package, please create an issue in this repository.
 
 Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.
 
@@ -64,28 +64,16 @@ yarn install
 
 ### Build
 
-If this is your **first** time building this package, you must first build **all** packages within the monorepo. This is because packages that depend on other packages located inside this monorepo are symlinked when run from **within** the monorepo. This allows you to make changes across multiple packages without first publishing dependent packages to NPM. To build all packages, run the following from the monorepo root directory:
+To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
 
 ```bash
-yarn lerna:rebuild
+PKG=0x.js yarn build
 ```
 
 Or continuously rebuild on change:
 
 ```bash
-yarn dev
-```
-
-You can also build this specific package by running the following from within its directory:
-
-```bash
-yarn build
-```
-
-or continuously rebuild on change:
-
-```bash
-yarn build:watch
+PKG=0x.js yarn watch
 ```
 
 ### Clean

packages/0x.js/package.json

@@ -1,6 +1,9 @@
 {
     "name": "0x.js",
-    "version": "0.36.3",
+    "version": "0.37.2",
+    "engines": {
+        "node": ">=6.12"
+    },
     "description": "A javascript library for interacting with the 0x protocol",
     "keywords": [
         "0x.js",
@@ -12,29 +15,27 @@
     "main": "lib/src/index.js",
     "types": "lib/src/index.d.ts",
     "scripts": {
-        "build:watch": "tsc -w",
+        "watch": "tsc -w",
         "prebuild": "run-s clean generate_contract_wrappers",
         "build": "run-p build:umd:prod build:commonjs; exit 0;",
-        "generate_contract_wrappers": "node ../abi-gen/lib/index.js --abis 'src/compact_artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry|DummyToken).json' --template ../contract_templates/contract.handlebars --partials '../contract_templates/partials/**/*.handlebars' --output src/contract_wrappers/generated --backend ethers && prettier --write 'src/contract_wrappers/generated/**.ts'",
-        "lint": "tslint --project . 'src/**/*.ts' 'test/**/*.ts'",
+        "generate_contract_wrappers": "abi-gen --abis 'src/compact_artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry|DummyToken).json' --template ../contract_templates/contract.handlebars --partials '../contract_templates/partials/**/*.handlebars' --output src/contract_wrappers/generated --backend ethers && prettier --write 'src/contract_wrappers/generated/**.ts'",
+        "lint": "tslint --project .",
         "test:circleci": "run-s test:coverage",
         "test": "run-s clean test:commonjs",
         "test:coverage": "nyc npm run test --all && yarn coverage:report:lcov",
         "coverage:report:lcov": "nyc report --reporter=text-lcov > coverage/lcov.info",
-        "update_artifacts": "for i in ${npm_package_config_contracts}; do copyfiles -u 4 ../migrations/src/artifacts/$i.json test/artifacts; done;",
-        "clean": "shx rm -rf _bundles lib test_temp scripts",
+        "clean": "shx rm -rf _bundles lib test_temp scripts src/contract_wrappers/generated",
         "build:umd:prod": "NODE_ENV=production webpack",
-        "build:commonjs": "tsc && yarn update_artifacts && copyfiles -u 2 './src/compact_artifacts/**/*.json' ./lib/src/compact_artifacts && copyfiles -u 3 './lib/src/monorepo_scripts/**/*' ./scripts",
+        "build:commonjs": "tsc && copyfiles -u 2 './src/compact_artifacts/**/*.json' ./lib/src/compact_artifacts && copyfiles -u 3 './lib/src/monorepo_scripts/**/*' ./scripts",
         "test:commonjs": "run-s build:commonjs run_mocha",
-        "run_mocha": "mocha lib/test/**/*_test.js --timeout 10000 --bail --exit",
+        "run_mocha": "mocha lib/test/**/*_test.js lib/test/global_hooks.js --timeout 10000 --bail --exit",
         "manual:postpublish": "yarn build; node ./scripts/postpublish.js",
-        "docs:stage": "yarn build && node ./scripts/stage_docs.js",
+        "docs:stage": "node scripts/stage_docs.js",
         "docs:json": "typedoc --excludePrivate --excludeExternals --target ES5 --json $JSON_FILE_PATH $PROJECT_FILES",
         "upload_docs_json": "aws s3 cp generated_docs/index.json $S3_URL --profile 0xproject --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers --content-type application/json"
     },
     "config": {
         "compact_artifacts": "Exchange DummyToken ZRXToken Token EtherToken TokenTransferProxy TokenRegistry",
-        "contracts": "Exchange DummyToken ZRXToken Token WETH9 TokenTransferProxy MultiSigWallet MultiSigWalletWithTimeLock MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress MaliciousToken TokenRegistry Arbitrage EtherDelta AccountLevels",
         "postpublish": {
             "assets": [
                 "packages/0x.js/_bundles/index.js",
@@ -43,6 +44,13 @@
             "docPublishConfigs": {
                 "extraFileIncludes": [
                     "../types/src/index.ts",
+                    "../contract-wrappers/src/types.ts",
+                    "../contract-wrappers/src/contract_wrappers/ether_token_wrapper.ts",
+                    "../contract-wrappers/src/contract_wrappers/exchange_wrapper.ts",
+                    "../contract-wrappers/src/contract_wrappers/token_registry_wrapper.ts",
+                    "../contract-wrappers/src/contract_wrappers/token_transfer_proxy_wrapper.ts",
+                    "../contract-wrappers/src/contract_wrappers/token_wrapper.ts",
+                    "../order-watcher/src/order_watcher/order_watcher.ts",
                     "./src/contract_wrappers/generated/ether_token.ts",
                     "./src/contract_wrappers/generated/token.ts",
                     "./src/contract_wrappers/generated/exchange.ts"
@@ -57,23 +65,17 @@
         "url": "https://github.com/0xProject/0x-monorepo"
     },
     "license": "Apache-2.0",
-    "engines": {
-        "node": ">=6.0.0"
-    },
     "devDependencies": {
-        "@0xproject/deployer": "^0.4.1",
-        "@0xproject/dev-utils": "^0.3.6",
-        "@0xproject/migrations": "^0.0.3",
-        "@0xproject/monorepo-scripts": "^0.1.18",
-        "@0xproject/subproviders": "^0.9.0",
-        "@0xproject/tslint-config": "^0.4.16",
-        "@types/bintrees": "^1.0.2",
+        "@0xproject/abi-gen": "^0.2.13",
+        "@0xproject/dev-utils": "^0.4.1",
+        "@0xproject/migrations": "^0.0.5",
+        "@0xproject/monorepo-scripts": "^0.1.19",
+        "@0xproject/sol-compiler": "^0.4.3",
+        "@0xproject/tslint-config": "^0.4.17",
         "@types/lodash": "4.14.104",
         "@types/mocha": "^2.2.42",
         "@types/node": "^8.0.53",
-        "@types/request": "2.47.0",
         "@types/sinon": "^2.2.2",
-        "@types/uuid": "^3.4.2",
         "awesome-typescript-loader": "^3.1.3",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
@@ -81,39 +83,33 @@
         "copyfiles": "^1.2.0",
         "dirty-chai": "^2.0.1",
         "json-loader": "^0.5.4",
+        "make-promises-safe": "^1.1.0",
         "mocha": "^4.0.1",
         "npm-run-all": "^4.1.2",
         "nyc": "^11.0.1",
         "opn-cli": "^3.1.0",
         "prettier": "^1.11.1",
-        "request": "^2.81.0",
         "shx": "^0.2.2",
         "sinon": "^4.0.0",
         "source-map-support": "^0.5.0",
         "tslint": "5.8.0",
         "typedoc": "0xProject/typedoc",
         "typescript": "2.7.1",
-        "web3-provider-engine": "^13.0.1",
         "webpack": "^3.1.0"
     },
     "dependencies": {
-        "@0xproject/assert": "^0.2.7",
-        "@0xproject/base-contract": "^0.2.1",
-        "@0xproject/json-schemas": "^0.7.21",
-        "@0xproject/types": "^0.6.1",
-        "@0xproject/typescript-typings": "^0.2.0",
-        "@0xproject/utils": "^0.5.2",
-        "@0xproject/web3-wrapper": "^0.6.1",
-        "bintrees": "^1.0.2",
-        "bn.js": "^4.11.8",
-        "ethereumjs-abi": "^0.6.4",
-        "ethereumjs-blockstream": "^2.0.6",
-        "ethereumjs-util": "^5.1.1",
-        "ethers-contracts": "^2.2.1",
-        "js-sha3": "^0.7.0",
-        "lodash": "^4.17.4",
-        "uuid": "^3.1.0",
-        "web3": "^0.20.0"
+        "@0xproject/assert": "^0.2.9",
+        "@0xproject/base-contract": "^0.3.1",
+        "@0xproject/contract-wrappers": "^0.0.1",
+        "@0xproject/order-utils": "^0.0.4",
+        "@0xproject/order-watcher": "^0.0.1",
+        "@0xproject/sol-compiler": "^0.4.3",
+        "@0xproject/types": "^0.6.3",
+        "@0xproject/typescript-typings": "^0.3.1",
+        "@0xproject/utils": "^0.6.1",
+        "@0xproject/web3-wrapper": "^0.6.3",
+        "ethers": "^3.0.15",
+        "lodash": "^4.17.4"
     },
     "publishConfig": {
         "access": "public"

packages/0x.js/src/0x.ts

@@ -1,26 +1,27 @@
-import { schemas, SchemaValidator } from '@0xproject/json-schemas';
+import { assert } from '@0xproject/assert';
+import {
+    ContractWrappers,
+    ContractWrappersConfig,
+    EtherTokenWrapper,
+    ExchangeWrapper,
+    TokenRegistryWrapper,
+    TokenTransferProxyWrapper,
+    TokenWrapper,
+} from '@0xproject/contract-wrappers';
+import {
+    generatePseudoRandomSalt,
+    getOrderHashHex,
+    isValidOrderHash,
+    isValidSignature,
+    signOrderHashAsync,
+} from '@0xproject/order-utils';
+import { OrderWatcher, OrderWatcherConfig } from '@0xproject/order-watcher';
 import { ECSignature, Order, Provider, SignedOrder, TransactionReceiptWithDecodedLogs } from '@0xproject/types';
-import { AbiDecoder, BigNumber, intervalUtils } from '@0xproject/utils';
+import { BigNumber } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import * as ethUtil from 'ethereumjs-util';
 import * as _ from 'lodash';
 
-import { artifacts } from './artifacts';
-import { EtherTokenWrapper } from './contract_wrappers/ether_token_wrapper';
-import { ExchangeWrapper } from './contract_wrappers/exchange_wrapper';
-import { TokenRegistryWrapper } from './contract_wrappers/token_registry_wrapper';
-import { TokenTransferProxyWrapper } from './contract_wrappers/token_transfer_proxy_wrapper';
-import { TokenWrapper } from './contract_wrappers/token_wrapper';
-import { OrderStateWatcher } from './order_watcher/order_state_watcher';
-import { zeroExConfigSchema } from './schemas/zero_ex_config_schema';
-import { zeroExPrivateNetworkConfigSchema } from './schemas/zero_ex_private_network_config_schema';
-import { zeroExPublicNetworkConfigSchema } from './schemas/zero_ex_public_network_config_schema';
-import { OrderStateWatcherConfig, ZeroExConfig, ZeroExError } from './types';
-import { assert } from './utils/assert';
 import { constants } from './utils/constants';
-import { decorators } from './utils/decorators';
-import { signatureUtils } from './utils/signature_utils';
-import { utils } from './utils/utils';
 
 /**
  * The ZeroEx class is the single entry-point into the 0x.js library. It contains all of the library's functionality
@@ -33,7 +34,6 @@ export class ZeroEx {
      * this constant for your convenience.
      */
     public static NULL_ADDRESS = constants.NULL_ADDRESS;
-
     /**
      * An instance of the ExchangeWrapper class containing methods for interacting with the 0x Exchange smart contract.
      */
@@ -57,7 +57,16 @@ export class ZeroEx {
      * tokenTransferProxy smart contract.
      */
     public proxy: TokenTransferProxyWrapper;
-    private _web3Wrapper: Web3Wrapper;
+    private _contractWrappers: ContractWrappers;
+    /**
+     * Generates a pseudo-random 256-bit salt.
+     * The salt can be included in a 0x order, ensuring that the order generates a unique orderHash
+     * and will not collide with other outstanding orders that are identical in all other parameters.
+     * @return  A pseudo-random 256-bit number that can be used as a salt.
+     */
+    public static generatePseudoRandomSalt(): BigNumber {
+        return generatePseudoRandomSalt();
+    }
     /**
      * Verifies that the elliptic curve signature `signature` was generated
      * by signing `data` with the private key corresponding to the `signerAddress` address.
@@ -67,27 +76,15 @@ export class ZeroEx {
      * @return  Whether the signature is valid for the supplied signerAddress and data.
      */
     public static isValidSignature(data: string, signature: ECSignature, signerAddress: string): boolean {
-        assert.isHexString('data', data);
-        assert.doesConformToSchema('signature', signature, schemas.ecSignatureSchema);
-        assert.isETHAddressHex('signerAddress', signerAddress);
-        const normalizedSignerAddress = signerAddress.toLowerCase();
-
-        const isValidSignature = signatureUtils.isValidSignature(data, signature, normalizedSignerAddress);
-        return isValidSignature;
+        return isValidSignature(data, signature, signerAddress);
     }
     /**
-     * Generates a pseudo-random 256-bit salt.
-     * The salt can be included in a 0x order, ensuring that the order generates a unique orderHash
-     * and will not collide with other outstanding orders that are identical in all other parameters.
-     * @return  A pseudo-random 256-bit number that can be used as a salt.
+     * Computes the orderHash for a supplied order.
+     * @param   order   An object that conforms to the Order or SignedOrder interface definitions.
+     * @return  The resulting orderHash from hashing the supplied order.
      */
-    public static generatePseudoRandomSalt(): BigNumber {
-        // BigNumber.random returns a pseudo-random number between 0 & 1 with a passed in number of decimal places.
-        // Source: https://mikemcl.github.io/bignumber.js/#random
-        const randomNumber = BigNumber.random(constants.MAX_DIGITS_IN_UNSIGNED_256_INT);
-        const factor = new BigNumber(10).pow(constants.MAX_DIGITS_IN_UNSIGNED_256_INT - 1);
-        const salt = randomNumber.times(factor).round();
-        return salt;
+    public static getOrderHashHex(order: Order | SignedOrder): string {
+        return getOrderHashHex(order);
     }
     /**
      * Checks if the supplied hex encoded order hash is valid.
@@ -97,12 +94,7 @@ export class ZeroEx {
      * @return  Whether the supplied orderHash has the expected format.
      */
     public static isValidOrderHash(orderHash: string): boolean {
-        // Since this method can be called to check if any arbitrary string conforms to an orderHash's
-        // format, we only assert that we were indeed passed a string.
-        assert.isString('orderHash', orderHash);
-        const schemaValidator = new SchemaValidator();
-        const isValidOrderHash = schemaValidator.validate(orderHash, schemas.orderHashSchema).valid;
-        return isValidOrderHash;
+        return isValidOrderHash(orderHash);
     }
     /**
      * A unit amount is defined as the amount of a token above the specified decimal places (integer part).
@@ -132,17 +124,6 @@ export class ZeroEx {
         const baseUnitAmount = Web3Wrapper.toBaseUnitAmount(amount, decimals);
         return baseUnitAmount;
     }
-    /**
-     * Computes the orderHash for a supplied order.
-     * @param   order   An object that conforms to the Order or SignedOrder interface definitions.
-     * @return  The resulting orderHash from hashing the supplied order.
-     */
-    @decorators.syncZeroExErrorHandler
-    public static getOrderHashHex(order: Order | SignedOrder): string {
-        assert.doesConformToSchema('order', order, schemas.orderSchema);
-        const orderHashHex = utils.getOrderHashHex(order);
-        return orderHashHex;
-    }
     /**
      * Instantiates a new ZeroEx instance that provides the public interface to the 0x.js library.
      * @param   provider    The Provider instance you would like the 0x.js library to use for interacting with
@@ -150,40 +131,15 @@ export class ZeroEx {
      * @param   config      The configuration object. Look up the type for the description.
      * @return  An instance of the 0x.js ZeroEx class.
      */
-    constructor(provider: Provider, config: ZeroExConfig) {
+    constructor(provider: Provider, config: ContractWrappersConfig) {
         assert.isWeb3Provider('provider', provider);
-        assert.doesConformToSchema('config', config, zeroExConfigSchema, [
-            zeroExPrivateNetworkConfigSchema,
-            zeroExPublicNetworkConfigSchema,
-        ]);
-        const artifactJSONs = _.values(artifacts);
-        const abiArrays = _.map(artifactJSONs, artifact => artifact.abi);
-        const defaults = {
-            gasPrice: config.gasPrice,
-        };
-        this._web3Wrapper = new Web3Wrapper(provider, defaults);
-        _.forEach(abiArrays, abi => {
-            this._web3Wrapper.abiDecoder.addABI(abi);
-        });
-        this.proxy = new TokenTransferProxyWrapper(
-            this._web3Wrapper,
-            config.networkId,
-            config.tokenTransferProxyContractAddress,
-        );
-        this.token = new TokenWrapper(this._web3Wrapper, config.networkId, this.proxy);
-        this.exchange = new ExchangeWrapper(
-            this._web3Wrapper,
-            config.networkId,
-            this.token,
-            config.exchangeContractAddress,
-            config.zrxContractAddress,
-        );
-        this.tokenRegistry = new TokenRegistryWrapper(
-            this._web3Wrapper,
-            config.networkId,
-            config.tokenRegistryContractAddress,
-        );
-        this.etherToken = new EtherTokenWrapper(this._web3Wrapper, config.networkId, this.token);
+        this._contractWrappers = new ContractWrappers(provider, config);
+
+        this.proxy = this._contractWrappers.proxy;
+        this.token = this._contractWrappers.token;
+        this.exchange = this._contractWrappers.exchange;
+        this.tokenRegistry = this._contractWrappers.tokenRegistry;
+        this.etherToken = this._contractWrappers.etherToken;
     }
     /**
      * Sets a new web3 provider for 0x.js. Updating the provider will stop all
@@ -192,24 +148,23 @@ export class ZeroEx {
      * @param   networkId   The id of the network your provider is connected to
      */
     public setProvider(provider: Provider, networkId: number): void {
-        this._web3Wrapper.setProvider(provider);
-        (this.exchange as any)._invalidateContractInstances();
-        (this.exchange as any)._setNetworkId(networkId);
-        (this.tokenRegistry as any)._invalidateContractInstance();
-        (this.tokenRegistry as any)._setNetworkId(networkId);
-        (this.token as any)._invalidateContractInstances();
-        (this.token as any)._setNetworkId(networkId);
-        (this.proxy as any)._invalidateContractInstance();
-        (this.proxy as any)._setNetworkId(networkId);
-        (this.etherToken as any)._invalidateContractInstance();
-        (this.etherToken as any)._setNetworkId(networkId);
+        this._contractWrappers.setProvider(provider, networkId);
+    }
+    /**
+     * Get the provider instance currently used by 0x.js
+     * @return  Web3 provider instance
+     */
+    public getProvider(): Provider {
+        return this._contractWrappers.getProvider();
     }
     /**
      * Get user Ethereum addresses available through the supplied web3 provider available for sending transactions.
      * @return  An array of available user Ethereum addresses.
      */
     public async getAvailableAddressesAsync(): Promise<string[]> {
-        const availableAddresses = await this._web3Wrapper.getAvailableAddressesAsync();
+        // Hack: Get Web3Wrapper from ContractWrappers
+        const web3Wrapper: Web3Wrapper = (this._contractWrappers as any)._web3Wrapper;
+        const availableAddresses = await web3Wrapper.getAvailableAddressesAsync();
         return availableAddresses;
     }
     /**
@@ -229,41 +184,12 @@ export class ZeroEx {
         signerAddress: string,
         shouldAddPersonalMessagePrefix: boolean,
     ): Promise<ECSignature> {
-        assert.isHexString('orderHash', orderHash);
-        await assert.isSenderAddressAsync('signerAddress', signerAddress, this._web3Wrapper);
-        const normalizedSignerAddress = signerAddress.toLowerCase();
-
-        let msgHashHex = orderHash;
-        if (shouldAddPersonalMessagePrefix) {
-            const orderHashBuff = ethUtil.toBuffer(orderHash);
-            const msgHashBuff = ethUtil.hashPersonalMessage(orderHashBuff);
-            msgHashHex = ethUtil.bufferToHex(msgHashBuff);
-        }
-
-        const signature = await this._web3Wrapper.signMessageAsync(normalizedSignerAddress, msgHashHex);
-
-        // HACK: There is no consensus on whether the signatureHex string should be formatted as
-        // v + r + s OR r + s + v, and different clients (even different versions of the same client)
-        // return the signature params in different orders. In order to support all client implementations,
-        // we parse the signature in both ways, and evaluate if either one is a valid signature.
-        const validVParamValues = [27, 28];
-        const ecSignatureVRS = signatureUtils.parseSignatureHexAsVRS(signature);
-        if (_.includes(validVParamValues, ecSignatureVRS.v)) {
-            const isValidVRSSignature = ZeroEx.isValidSignature(orderHash, ecSignatureVRS, normalizedSignerAddress);
-            if (isValidVRSSignature) {
-                return ecSignatureVRS;
-            }
-        }
-
-        const ecSignatureRSV = signatureUtils.parseSignatureHexAsRSV(signature);
-        if (_.includes(validVParamValues, ecSignatureRSV.v)) {
-            const isValidRSVSignature = ZeroEx.isValidSignature(orderHash, ecSignatureRSV, normalizedSignerAddress);
-            if (isValidRSVSignature) {
-                return ecSignatureRSV;
-            }
-        }
-
-        throw new Error(ZeroExError.InvalidSignature);
+        return signOrderHashAsync(
+            this._contractWrappers.getProvider(),
+            orderHash,
+            signerAddress,
+            shouldAddPersonalMessagePrefix,
+        );
     }
     /**
      * Waits for a transaction to be mined and returns the transaction receipt.
@@ -274,10 +200,12 @@ export class ZeroEx {
      */
     public async awaitTransactionMinedAsync(
         txHash: string,
-        pollingIntervalMs = 1000,
+        pollingIntervalMs: number = 1000,
         timeoutMs?: number,
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const transactionReceiptWithDecodedLogs = await this._web3Wrapper.awaitTransactionMinedAsync(
+        // Hack: Get Web3Wrapper from ContractWrappers
+        const web3Wrapper: Web3Wrapper = (this._contractWrappers as any)._web3Wrapper;
+        const transactionReceiptWithDecodedLogs = await web3Wrapper.awaitTransactionMinedAsync(
             txHash,
             pollingIntervalMs,
             timeoutMs,
@@ -285,22 +213,17 @@ export class ZeroEx {
         return transactionReceiptWithDecodedLogs;
     }
     /**
-     * Instantiates and returns a new OrderStateWatcher instance.
+     * Instantiates and returns a new OrderWatcher instance.
      * Defaults to watching the pending state.
      * @param   config      The configuration object. Look up the type for the description.
-     * @return  An instance of the 0x.js OrderStateWatcher class.
+     * @return  An instance of the 0x.js OrderWatcher class.
      */
-    public createOrderStateWatcher(config?: OrderStateWatcherConfig) {
-        return new OrderStateWatcher(this._web3Wrapper, this.token, this.exchange, config);
-    }
-    /*
-     * HACK: `TokenWrapper` needs a token transfer proxy address. `TokenTransferProxy` address is fetched from
-     * an `ExchangeWrapper`. `ExchangeWrapper` needs `TokenWrapper` to validate orders, creating a dependency cycle.
-     * In order to break this - we create this function here and pass it as a parameter to the `TokenWrapper`
-     * and `ProxyWrapper`.
-     */
-    private async _getTokenTransferProxyAddressAsync(): Promise<string> {
-        const tokenTransferProxyAddress = await (this.exchange as any)._getTokenTransferProxyAddressAsync();
-        return tokenTransferProxyAddress;
+    public async createOrderWatcherAsync(config?: OrderWatcherConfig): Promise<OrderWatcher> {
+        // Hack: Get Web3Wrapper from ContractWrappers
+        const web3Wrapper: Web3Wrapper = (this._contractWrappers as any)._web3Wrapper;
+        const networkId = await web3Wrapper.getNetworkIdAsync();
+        const provider = this._contractWrappers.getProvider();
+        const orderWatcher = new OrderWatcher(provider, networkId, config);
+        return orderWatcher;
     }
 }

packages/0x.js/src/artifacts.ts

@@ -1,18 +0,0 @@
-import * as DummyTokenArtifact from './compact_artifacts/DummyToken.json';
-import * as EtherTokenArtifact from './compact_artifacts/EtherToken.json';
-import * as ExchangeArtifact from './compact_artifacts/Exchange.json';
-import * as TokenArtifact from './compact_artifacts/Token.json';
-import * as TokenRegistryArtifact from './compact_artifacts/TokenRegistry.json';
-import * as TokenTransferProxyArtifact from './compact_artifacts/TokenTransferProxy.json';
-import * as ZRXArtifact from './compact_artifacts/ZRX.json';
-import { Artifact } from './types';
-
-export const artifacts = {
-    ZRXArtifact: (ZRXArtifact as any) as Artifact,
-    DummyTokenArtifact: (DummyTokenArtifact as any) as Artifact,
-    TokenArtifact: (TokenArtifact as any) as Artifact,
-    ExchangeArtifact: (ExchangeArtifact as any) as Artifact,
-    EtherTokenArtifact: (EtherTokenArtifact as any) as Artifact,
-    TokenRegistryArtifact: (TokenRegistryArtifact as any) as Artifact,
-    TokenTransferProxyArtifact: (TokenTransferProxyArtifact as any) as Artifact,
-};

packages/0x.js/src/index.ts

@@ -1,61 +1,51 @@
 export { ZeroEx } from './0x';
 
-export {
-    ZeroExError,
-    EventCallback,
-    ExchangeContractErrs,
-    ContractEvent,
-    Token,
-    IndexedFilterValues,
-    BlockRange,
-    OrderCancellationRequest,
-    OrderFillRequest,
-    ContractEventArgs,
-    ZeroExConfig,
-    MethodOpts,
-    OrderTransactionOpts,
-    TransactionOpts,
-    LogEvent,
-    DecodedLogEvent,
-    EventWatcherCallback,
-    OnOrderStateChangeCallback,
-    OrderStateValid,
-    OrderStateInvalid,
-    OrderState,
-} from './types';
-
 export {
     BlockParamLiteral,
     FilterObject,
     BlockParam,
     ContractEventArg,
+    ExchangeContractErrs,
     LogWithDecodedArgs,
     Order,
     Provider,
     SignedOrder,
     ECSignature,
+    OrderStateValid,
+    OrderStateInvalid,
+    OrderState,
+    Token,
     TransactionReceipt,
     TransactionReceiptWithDecodedLogs,
 } from '@0xproject/types';
 
 export {
+    EventCallback,
+    ContractEvent,
+    IndexedFilterValues,
+    BlockRange,
+    OrderCancellationRequest,
+    OrderFillRequest,
+    ContractEventArgs,
+    MethodOpts,
+    OrderTransactionOpts,
+    TransactionOpts,
+    LogEvent,
+    DecodedLogEvent,
+    OnOrderStateChangeCallback,
+    ContractWrappersError,
     EtherTokenContractEventArgs,
     WithdrawalContractEventArgs,
     DepositContractEventArgs,
     EtherTokenEvents,
-} from './contract_wrappers/generated/ether_token';
-
-export {
     TransferContractEventArgs,
     ApprovalContractEventArgs,
     TokenContractEventArgs,
     TokenEvents,
-} from './contract_wrappers/generated/token';
-
-export {
     LogErrorContractEventArgs,
     LogCancelContractEventArgs,
     LogFillContractEventArgs,
     ExchangeContractEventArgs,
     ExchangeEvents,
-} from './contract_wrappers/generated/exchange';
+    ContractWrappersConfig,
+} from '@0xproject/contract-wrappers';

packages/0x.js/src/schemas/zero_ex_public_network_config_schema.ts

@@ -1,9 +1,23 @@
+const networkNameToId: { [networkName: string]: number } = {
+    mainnet: 1,
+    ropsten: 3,
+    rinkeby: 4,
+    kovan: 42,
+    ganache: 50,
+};
+
 export const zeroExPublicNetworkConfigSchema = {
     id: '/ZeroExPublicNetworkConfig',
     properties: {
         networkId: {
             type: 'number',
-            enum: [1, 3, 4, 42, 50],
+            enum: [
+                networkNameToId.mainnet,
+                networkNameToId.ropsten,
+                networkNameToId.rinkeby,
+                networkNameToId.kovan,
+                networkNameToId.ganache,
+            ],
         },
         gasPrice: { $ref: '/Number' },
         zrxContractAddress: { $ref: '/Address' },

packages/0x.js/src/types.ts

@@ -1,277 +1,20 @@
-import { BigNumber } from '@0xproject/utils';
-
 import {
     BlockParam,
     BlockParamLiteral,
     ContractAbi,
     ContractEventArg,
+    ExchangeContractErrs,
     FilterObject,
-    LogEntryEvent,
     LogWithDecodedArgs,
     Order,
+    OrderState,
     SignedOrder,
 } from '@0xproject/types';
 
-import * as Web3 from 'web3';
-
-import { EtherTokenContractEventArgs, EtherTokenEvents } from './contract_wrappers/generated/ether_token';
-import { ExchangeContractEventArgs, ExchangeEvents } from './contract_wrappers/generated/exchange';
-import { TokenContractEventArgs, TokenEvents } from './contract_wrappers/generated/token';
-
-export enum ZeroExError {
-    ExchangeContractDoesNotExist = 'EXCHANGE_CONTRACT_DOES_NOT_EXIST',
-    ZRXContractDoesNotExist = 'ZRX_CONTRACT_DOES_NOT_EXIST',
-    EtherTokenContractDoesNotExist = 'ETHER_TOKEN_CONTRACT_DOES_NOT_EXIST',
-    TokenTransferProxyContractDoesNotExist = 'TOKEN_TRANSFER_PROXY_CONTRACT_DOES_NOT_EXIST',
-    TokenRegistryContractDoesNotExist = 'TOKEN_REGISTRY_CONTRACT_DOES_NOT_EXIST',
-    TokenContractDoesNotExist = 'TOKEN_CONTRACT_DOES_NOT_EXIST',
-    UnhandledError = 'UNHANDLED_ERROR',
-    UserHasNoAssociatedAddress = 'USER_HAS_NO_ASSOCIATED_ADDRESSES',
-    InvalidSignature = 'INVALID_SIGNATURE',
-    ContractNotDeployedOnNetwork = 'CONTRACT_NOT_DEPLOYED_ON_NETWORK',
-    InsufficientAllowanceForTransfer = 'INSUFFICIENT_ALLOWANCE_FOR_TRANSFER',
-    InsufficientBalanceForTransfer = 'INSUFFICIENT_BALANCE_FOR_TRANSFER',
-    InsufficientEthBalanceForDeposit = 'INSUFFICIENT_ETH_BALANCE_FOR_DEPOSIT',
-    InsufficientWEthBalanceForWithdrawal = 'INSUFFICIENT_WETH_BALANCE_FOR_WITHDRAWAL',
-    InvalidJump = 'INVALID_JUMP',
-    OutOfGas = 'OUT_OF_GAS',
-    NoNetworkId = 'NO_NETWORK_ID',
-    SubscriptionNotFound = 'SUBSCRIPTION_NOT_FOUND',
-    SubscriptionAlreadyPresent = 'SUBSCRIPTION_ALREADY_PRESENT',
-}
-
 export enum InternalZeroExError {
     NoAbiDecoder = 'NO_ABI_DECODER',
     ZrxNotInTokenRegistry = 'ZRX_NOT_IN_TOKEN_REGISTRY',
     WethNotInTokenRegistry = 'WETH_NOT_IN_TOKEN_REGISTRY',
 }
 
-export type OrderAddresses = [string, string, string, string, string];
-
-export type OrderValues = [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber];
-
-export type LogEvent = LogEntryEvent;
-export interface DecodedLogEvent<ArgsType> {
-    isRemoved: boolean;
-    log: LogWithDecodedArgs<ArgsType>;
-}
-
-export type EventCallback<ArgsType> = (err: null | Error, log?: DecodedLogEvent<ArgsType>) => void;
-export type EventWatcherCallback = (err: null | Error, log?: LogEvent) => void;
-
-export enum ExchangeContractErrCodes {
-    ERROR_FILL_EXPIRED, // Order has already expired
-    ERROR_FILL_NO_VALUE, // Order has already been fully filled or cancelled
-    ERROR_FILL_TRUNCATION, // Rounding error too large
-    ERROR_FILL_BALANCE_ALLOWANCE, // Insufficient balance or allowance for token transfer
-    ERROR_CANCEL_EXPIRED, // Order has already expired
-    ERROR_CANCEL_NO_VALUE, // Order has already been fully filled or cancelled
-}
-
-export enum ExchangeContractErrs {
-    OrderFillExpired = 'ORDER_FILL_EXPIRED',
-    OrderCancelExpired = 'ORDER_CANCEL_EXPIRED',
-    OrderCancelAmountZero = 'ORDER_CANCEL_AMOUNT_ZERO',
-    OrderAlreadyCancelledOrFilled = 'ORDER_ALREADY_CANCELLED_OR_FILLED',
-    OrderFillAmountZero = 'ORDER_FILL_AMOUNT_ZERO',
-    OrderRemainingFillAmountZero = 'ORDER_REMAINING_FILL_AMOUNT_ZERO',
-    OrderFillRoundingError = 'ORDER_FILL_ROUNDING_ERROR',
-    FillBalanceAllowanceError = 'FILL_BALANCE_ALLOWANCE_ERROR',
-    InsufficientTakerBalance = 'INSUFFICIENT_TAKER_BALANCE',
-    InsufficientTakerAllowance = 'INSUFFICIENT_TAKER_ALLOWANCE',
-    InsufficientMakerBalance = 'INSUFFICIENT_MAKER_BALANCE',
-    InsufficientMakerAllowance = 'INSUFFICIENT_MAKER_ALLOWANCE',
-    InsufficientTakerFeeBalance = 'INSUFFICIENT_TAKER_FEE_BALANCE',
-    InsufficientTakerFeeAllowance = 'INSUFFICIENT_TAKER_FEE_ALLOWANCE',
-    InsufficientMakerFeeBalance = 'INSUFFICIENT_MAKER_FEE_BALANCE',
-    InsufficientMakerFeeAllowance = 'INSUFFICIENT_MAKER_FEE_ALLOWANCE',
-    TransactionSenderIsNotFillOrderTaker = 'TRANSACTION_SENDER_IS_NOT_FILL_ORDER_TAKER',
-    MultipleMakersInSingleCancelBatchDisallowed = 'MULTIPLE_MAKERS_IN_SINGLE_CANCEL_BATCH_DISALLOWED',
-    InsufficientRemainingFillAmount = 'INSUFFICIENT_REMAINING_FILL_AMOUNT',
-    MultipleTakerTokensInFillUpToDisallowed = 'MULTIPLE_TAKER_TOKENS_IN_FILL_UP_TO_DISALLOWED',
-    BatchOrdersMustHaveSameExchangeAddress = 'BATCH_ORDERS_MUST_HAVE_SAME_EXCHANGE_ADDRESS',
-    BatchOrdersMustHaveAtLeastOneItem = 'BATCH_ORDERS_MUST_HAVE_AT_LEAST_ONE_ITEM',
-}
-
-export interface ContractEvent {
-    logIndex: number;
-    transactionIndex: number;
-    transactionHash: string;
-    blockHash: string;
-    blockNumber: number;
-    address: string;
-    type: string;
-    event: string;
-    args: ContractEventArgs;
-}
-
-export type ContractEventArgs = ExchangeContractEventArgs | TokenContractEventArgs | EtherTokenContractEventArgs;
-
-//                          [address, name, symbol, decimals, ipfsHash, swarmHash]
-export type TokenMetadata = [string, string, string, number, string, string];
-
-export interface Token {
-    name: string;
-    address: string;
-    symbol: string;
-    decimals: number;
-}
-
-export interface TxOpts {
-    from: string;
-    gas?: number;
-    value?: BigNumber;
-    gasPrice?: BigNumber;
-}
-
-export interface TokenAddressBySymbol {
-    [symbol: string]: string;
-}
-
-export type ContractEvents = TokenEvents | ExchangeEvents | EtherTokenEvents;
-
-export interface IndexedFilterValues {
-    [index: string]: ContractEventArg;
-}
-
-export interface BlockRange {
-    fromBlock: BlockParam;
-    toBlock: BlockParam;
-}
-
-export type DoneCallback = (err?: Error) => void;
-
-export interface OrderCancellationRequest {
-    order: Order | SignedOrder;
-    takerTokenCancelAmount: BigNumber;
-}
-
-export interface OrderFillRequest {
-    signedOrder: SignedOrder;
-    takerTokenFillAmount: BigNumber;
-}
-
-export type AsyncMethod = (...args: any[]) => Promise<any>;
-export type SyncMethod = (...args: any[]) => any;
-
-/**
- * orderExpirationCheckingIntervalMs: How often to check for expired orders. Default=50.
- * eventPollingIntervalMs: How often to poll the Ethereum node for new events. Default=200.
- * expirationMarginMs: Amount of time before order expiry that you'd like to be notified
- * of an orders expiration. Default=0.
- * cleanupJobIntervalMs: How often to run a cleanup job which revalidates all the orders. Default=1hr.
- * stateLayer: Optional blockchain state layer OrderWatcher will monitor for new events. Default=latest.
- */
-export interface OrderStateWatcherConfig {
-    orderExpirationCheckingIntervalMs?: number;
-    eventPollingIntervalMs?: number;
-    expirationMarginMs?: number;
-    cleanupJobIntervalMs?: number;
-    stateLayer: BlockParamLiteral;
-}
-
-/**
- * networkId: The id of the underlying ethereum network your provider is connected to. (1-mainnet, 3-ropsten, 4-rinkeby, 42-kovan, 50-testrpc)
- * gasPrice: Gas price to use with every transaction
- * exchangeContractAddress: The address of an exchange contract to use
- * zrxContractAddress: The address of the ZRX contract to use
- * tokenRegistryContractAddress: The address of a token registry contract to use
- * tokenTransferProxyContractAddress: The address of the token transfer proxy contract to use
- * orderWatcherConfig: All the configs related to the orderWatcher
- */
-export interface ZeroExConfig {
-    networkId: number;
-    gasPrice?: BigNumber;
-    exchangeContractAddress?: string;
-    zrxContractAddress?: string;
-    tokenRegistryContractAddress?: string;
-    tokenTransferProxyContractAddress?: string;
-    orderWatcherConfig?: OrderStateWatcherConfig;
-}
-
-export type ArtifactContractName = 'ZRX' | 'TokenTransferProxy' | 'TokenRegistry' | 'Token' | 'Exchange' | 'EtherToken';
-
-export interface Artifact {
-    contract_name: ArtifactContractName;
-    abi: ContractAbi;
-    networks: {
-        [networkId: number]: {
-            address: string;
-        };
-    };
-}
-
-/**
- * expectedFillTakerTokenAmount: If specified, the validation method will ensure that the
- * supplied order maker has a sufficient allowance/balance to fill this amount of the order's
- * takerTokenAmount. If not specified, the validation method ensures that the maker has a sufficient
- * allowance/balance to fill the entire remaining order amount.
- */
-export interface ValidateOrderFillableOpts {
-    expectedFillTakerTokenAmount?: BigNumber;
-}
-
-/**
- * defaultBlock: The block up to which to query the blockchain state. Setting this to a historical block number
- * let's the user query the blockchain's state at an arbitrary point in time. In order for this to work, the
- * backing  Ethereum node must keep the entire historical state of the chain (e.g setting `--pruning=archive`
- * flag when  running Parity).
- */
-export interface MethodOpts {
-    defaultBlock?: BlockParam;
-}
-
-/**
- * gasPrice: Gas price in Wei to use for a transaction
- * gasLimit: The amount of gas to send with a transaction
- */
-export interface TransactionOpts {
-    gasPrice?: BigNumber;
-    gasLimit?: number;
-}
-
-/**
- * shouldValidate: Flag indicating whether the library should make attempts to validate a transaction before
- * broadcasting it. For example, order has a valid signature, maker has sufficient funds, etc. Default=true.
- */
-export interface OrderTransactionOpts extends TransactionOpts {
-    shouldValidate?: boolean;
-}
-
-export enum TradeSide {
-    Maker = 'maker',
-    Taker = 'taker',
-}
-
-export enum TransferType {
-    Trade = 'trade',
-    Fee = 'fee',
-}
-
-export interface OrderRelevantState {
-    makerBalance: BigNumber;
-    makerProxyAllowance: BigNumber;
-    makerFeeBalance: BigNumber;
-    makerFeeProxyAllowance: BigNumber;
-    filledTakerTokenAmount: BigNumber;
-    cancelledTakerTokenAmount: BigNumber;
-    remainingFillableMakerTokenAmount: BigNumber;
-    remainingFillableTakerTokenAmount: BigNumber;
-}
-
-export interface OrderStateValid {
-    isValid: true;
-    orderHash: string;
-    orderRelevantState: OrderRelevantState;
-}
-
-export interface OrderStateInvalid {
-    isValid: false;
-    orderHash: string;
-    error: ExchangeContractErrs;
-}
-
-export type OrderState = OrderStateValid | OrderStateInvalid;
-
-export type OnOrderStateChangeCallback = (err: Error | null, orderState?: OrderState) => void;
 // tslint:disable:max-file-line-count

packages/0x.js/src/utils/constants.ts

@@ -3,10 +3,4 @@ import { BigNumber } from '@0xproject/utils';
 export const constants = {
     NULL_ADDRESS: '0x0000000000000000000000000000000000000000',
     TESTRPC_NETWORK_ID: 50,
-    MAX_DIGITS_IN_UNSIGNED_256_INT: 78,
-    INVALID_JUMP_PATTERN: 'invalid JUMP at',
-    OUT_OF_GAS_PATTERN: 'out of gas',
-    INVALID_TAKER_FORMAT: 'instance.taker is not of a type(s) string',
-    UNLIMITED_ALLOWANCE_IN_BASE_UNITS: new BigNumber(2).pow(256).minus(1),
-    DEFAULT_BLOCK_POLLING_INTERVAL: 1000,
 };

packages/0x.js/src/utils/signature_utils.ts

@@ -1,45 +0,0 @@
-import { ECSignature } from '@0xproject/types';
-import * as ethUtil from 'ethereumjs-util';
-
-export const signatureUtils = {
-    isValidSignature(data: string, signature: ECSignature, signerAddress: string): boolean {
-        const dataBuff = ethUtil.toBuffer(data);
-        const msgHashBuff = ethUtil.hashPersonalMessage(dataBuff);
-        try {
-            const pubKey = ethUtil.ecrecover(
-                msgHashBuff,
-                signature.v,
-                ethUtil.toBuffer(signature.r),
-                ethUtil.toBuffer(signature.s),
-            );
-            const retrievedAddress = ethUtil.bufferToHex(ethUtil.pubToAddress(pubKey));
-            return retrievedAddress === signerAddress;
-        } catch (err) {
-            return false;
-        }
-    },
-    parseSignatureHexAsVRS(signatureHex: string): ECSignature {
-        const signatureBuffer = ethUtil.toBuffer(signatureHex);
-        let v = signatureBuffer[0];
-        if (v < 27) {
-            v += 27;
-        }
-        const r = signatureBuffer.slice(1, 33);
-        const s = signatureBuffer.slice(33, 65);
-        const ecSignature: ECSignature = {
-            v,
-            r: ethUtil.bufferToHex(r),
-            s: ethUtil.bufferToHex(s),
-        };
-        return ecSignature;
-    },
-    parseSignatureHexAsRSV(signatureHex: string): ECSignature {
-        const { v, r, s } = ethUtil.fromRpcSig(signatureHex);
-        const ecSignature: ECSignature = {
-            v,
-            r: ethUtil.bufferToHex(r),
-            s: ethUtil.bufferToHex(s),
-        };
-        return ecSignature;
-    },
-};

packages/0x.js/src/utils/utils.ts

@@ -1,63 +0,0 @@
-import { Order, SignedOrder, SolidityTypes } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
-import BN = require('bn.js');
-import * as ethABI from 'ethereumjs-abi';
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-export const utils = {
-    /**
-     * Converts BigNumber instance to BN
-     * The only reason we convert to BN is to remain compatible with `ethABI. soliditySHA3` that
-     * expects values of Solidity type `uint` to be passed as type `BN`.
-     * We do not use BN anywhere else in the codebase.
-     */
-    bigNumberToBN(value: BigNumber) {
-        return new BN(value.toString(), 10);
-    },
-    spawnSwitchErr(name: string, value: any): Error {
-        return new Error(`Unexpected switch value: ${value} encountered for ${name}`);
-    },
-    getOrderHashHex(order: Order | SignedOrder): string {
-        const orderParts = [
-            { value: order.exchangeContractAddress, type: SolidityTypes.Address },
-            { value: order.maker, type: SolidityTypes.Address },
-            { value: order.taker, type: SolidityTypes.Address },
-            { value: order.makerTokenAddress, type: SolidityTypes.Address },
-            { value: order.takerTokenAddress, type: SolidityTypes.Address },
-            { value: order.feeRecipient, type: SolidityTypes.Address },
-            {
-                value: utils.bigNumberToBN(order.makerTokenAmount),
-                type: SolidityTypes.Uint256,
-            },
-            {
-                value: utils.bigNumberToBN(order.takerTokenAmount),
-                type: SolidityTypes.Uint256,
-            },
-            {
-                value: utils.bigNumberToBN(order.makerFee),
-                type: SolidityTypes.Uint256,
-            },
-            {
-                value: utils.bigNumberToBN(order.takerFee),
-                type: SolidityTypes.Uint256,
-            },
-            {
-                value: utils.bigNumberToBN(order.expirationUnixTimestampSec),
-                type: SolidityTypes.Uint256,
-            },
-            { value: utils.bigNumberToBN(order.salt), type: SolidityTypes.Uint256 },
-        ];
-        const types = _.map(orderParts, o => o.type);
-        const values = _.map(orderParts, o => o.value);
-        const hashBuff = ethABI.soliditySHA3(types, values);
-        const hashHex = ethUtil.bufferToHex(hashBuff);
-        return hashHex;
-    },
-    getCurrentUnixTimestampSec(): BigNumber {
-        return new BigNumber(Date.now() / 1000).round();
-    },
-    getCurrentUnixTimestampMs(): BigNumber {
-        return new BigNumber(Date.now());
-    },
-};

packages/0x.js/test/0x.js_test.ts

@@ -1,12 +1,9 @@
-import { Deployer } from '@0xproject/deployer';
+import { ContractWrappers } from '@0xproject/contract-wrappers';
 import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
-// HACK: This dependency is optional since it is only available when run from within
-// the monorepo. tslint doesn't handle optional dependencies
-// tslint:disable-next-line:no-implicit-dependencies
-import { runMigrationsAsync } from '@0xproject/migrations';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
 import * as _ from 'lodash';
+import 'make-promises-safe';
 import 'mocha';
 import * as path from 'path';
 import * as Sinon from 'sinon';
@@ -15,7 +12,6 @@ import { ApprovalContractEventArgs, LogWithDecodedArgs, Order, TokenEvents, Zero
 
 import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
-import { deployer } from './utils/deployer';
 import { TokenUtils } from './utils/token_utils';
 import { provider, web3Wrapper } from './utils/web3_wrapper';
 
@@ -23,12 +19,9 @@ const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 chaiSetup.configure();
 const expect = chai.expect;
 
-const SHOULD_ADD_PERSONAL_MESSAGE_PREFIX = false;
-
 describe('ZeroEx library', () => {
     let zeroEx: ZeroEx;
     before(async () => {
-        await runMigrationsAsync(deployer);
         const config = {
             networkId: constants.TESTRPC_NETWORK_ID,
         };
@@ -50,9 +43,9 @@ describe('ZeroEx library', () => {
             expect((zeroEx.exchange as any)._exchangeContractIfExists).to.be.undefined();
             expect((zeroEx.tokenRegistry as any)._tokenRegistryContractIfExists).to.be.undefined();
 
-            // Check that all nested web3 wrapper instances return the updated provider
-            const nestedWeb3WrapperProvider = (zeroEx as any)._web3Wrapper.getProvider();
-            expect(nestedWeb3WrapperProvider.zeroExTestId).to.be.a('number');
+            // Check that all nested zeroExContract/web3Wrapper instances return the updated provider
+            const nestedWeb3WrapperProvider = ((zeroEx as any)._contractWrappers as ContractWrappers).getProvider();
+            expect((nestedWeb3WrapperProvider as any).zeroExTestId).to.be.a('number');
             const exchangeWeb3WrapperProvider = (zeroEx.exchange as any)._web3Wrapper.getProvider();
             expect(exchangeWeb3WrapperProvider.zeroExTestId).to.be.a('number');
             const tokenRegistryWeb3WrapperProvider = (zeroEx.tokenRegistry as any)._web3Wrapper.getProvider();
@@ -70,14 +63,12 @@ describe('ZeroEx library', () => {
         };
         const address = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
         it("should return false if the data doesn't pertain to the signature & address", async () => {
-            expect(ZeroEx.isValidSignature('0x0', signature, address)).to.be.false();
             return expect(
                 (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync('0x0', signature, address),
             ).to.become(false);
         });
         it("should return false if the address doesn't pertain to the signature & data", async () => {
             const validUnrelatedAddress = '0x8b0292b11a196601ed2ce54b665cafeca0347d42';
-            expect(ZeroEx.isValidSignature(dataHex, signature, validUnrelatedAddress)).to.be.false();
             return expect(
                 (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(
                     dataHex,
@@ -88,45 +79,16 @@ describe('ZeroEx library', () => {
         });
         it("should return false if the signature doesn't pertain to the dataHex & address", async () => {
             const wrongSignature = _.assign({}, signature, { v: 28 });
-            expect(ZeroEx.isValidSignature(dataHex, wrongSignature, address)).to.be.false();
             return expect(
                 (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(dataHex, wrongSignature, address),
             ).to.become(false);
         });
         it('should return true if the signature does pertain to the dataHex & address', async () => {
-            const isValidSignatureLocal = ZeroEx.isValidSignature(dataHex, signature, address);
-            expect(isValidSignatureLocal).to.be.true();
             return expect(
                 (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(dataHex, signature, address),
             ).to.become(true);
         });
     });
-    describe('#generateSalt', () => {
-        it('generates different salts', () => {
-            const equal = ZeroEx.generatePseudoRandomSalt().eq(ZeroEx.generatePseudoRandomSalt());
-            expect(equal).to.be.false();
-        });
-        it('generates salt in range [0..2^256)', () => {
-            const salt = ZeroEx.generatePseudoRandomSalt();
-            expect(salt.greaterThanOrEqualTo(0)).to.be.true();
-            const twoPow256 = new BigNumber(2).pow(256);
-            expect(salt.lessThan(twoPow256)).to.be.true();
-        });
-    });
-    describe('#isValidOrderHash', () => {
-        it('returns false if the value is not a hex string', () => {
-            const isValid = ZeroEx.isValidOrderHash('not a hex');
-            expect(isValid).to.be.false();
-        });
-        it('returns false if the length is wrong', () => {
-            const isValid = ZeroEx.isValidOrderHash('0xdeadbeef');
-            expect(isValid).to.be.false();
-        });
-        it('returns true if order hash is correct', () => {
-            const isValid = ZeroEx.isValidOrderHash('0x' + Array(65).join('0'));
-            expect(isValid).to.be.true();
-        });
-    });
     describe('#toUnitAmount', () => {
         it('should throw if invalid baseUnit amount supplied as argument', () => {
             const invalidBaseUnitAmount = new BigNumber(1000000000.4);
@@ -159,106 +121,6 @@ describe('ZeroEx library', () => {
             );
         });
     });
-    describe('#getOrderHashHex', () => {
-        const expectedOrderHash = '0x39da987067a3c9e5f1617694f1301326ba8c8b0498ebef5df4863bed394e3c83';
-        const fakeExchangeContractAddress = '0xb69e673309512a9d726f87304c6984054f87a93b';
-        const order: Order = {
-            maker: constants.NULL_ADDRESS,
-            taker: constants.NULL_ADDRESS,
-            feeRecipient: constants.NULL_ADDRESS,
-            makerTokenAddress: constants.NULL_ADDRESS,
-            takerTokenAddress: constants.NULL_ADDRESS,
-            exchangeContractAddress: fakeExchangeContractAddress,
-            salt: new BigNumber(0),
-            makerFee: new BigNumber(0),
-            takerFee: new BigNumber(0),
-            makerTokenAmount: new BigNumber(0),
-            takerTokenAmount: new BigNumber(0),
-            expirationUnixTimestampSec: new BigNumber(0),
-        };
-        it('calculates the order hash', async () => {
-            const orderHash = ZeroEx.getOrderHashHex(order);
-            expect(orderHash).to.be.equal(expectedOrderHash);
-        });
-        it('throws a readable error message if taker format is invalid', async () => {
-            const orderWithInvalidtakerFormat = {
-                ...order,
-                taker: (null as any) as string,
-            };
-            const expectedErrorMessage =
-                'Order taker must be of type string. If you want anyone to be able to fill an order - pass ZeroEx.NULL_ADDRESS';
-            expect(() => ZeroEx.getOrderHashHex(orderWithInvalidtakerFormat)).to.throw(expectedErrorMessage);
-        });
-    });
-    describe('#signOrderHashAsync', () => {
-        let stubs: Sinon.SinonStub[] = [];
-        let makerAddress: string;
-        before(async () => {
-            const availableAddreses = await zeroEx.getAvailableAddressesAsync();
-            makerAddress = availableAddreses[0];
-        });
-        afterEach(() => {
-            // clean up any stubs after the test has completed
-            _.each(stubs, s => s.restore());
-            stubs = [];
-        });
-        it('Should return the correct ECSignature', async () => {
-            const orderHash = '0x6927e990021d23b1eb7b8789f6a6feaf98fe104bb0cf8259421b79f9a34222b0';
-            const expectedECSignature = {
-                v: 27,
-                r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
-                s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
-            };
-            const ecSignature = await zeroEx.signOrderHashAsync(
-                orderHash,
-                makerAddress,
-                SHOULD_ADD_PERSONAL_MESSAGE_PREFIX,
-            );
-            expect(ecSignature).to.deep.equal(expectedECSignature);
-        });
-        it('should return the correct ECSignature for signatureHex concatenated as R + S + V', async () => {
-            const orderHash = '0x34decbedc118904df65f379a175bb39ca18209d6ce41d5ed549d54e6e0a95004';
-            const signature =
-                '0x22109d11d79cb8bf96ed88625e1cd9558800c4073332a9a02857499883ee5ce3050aa3cc1f2c435e67e114cdce54b9527b4f50548342401bc5d2b77adbdacb021b';
-            const expectedECSignature = {
-                v: 27,
-                r: '0x22109d11d79cb8bf96ed88625e1cd9558800c4073332a9a02857499883ee5ce3',
-                s: '0x050aa3cc1f2c435e67e114cdce54b9527b4f50548342401bc5d2b77adbdacb02',
-            };
-            stubs = [
-                Sinon.stub((zeroEx as any)._web3Wrapper, 'signMessageAsync').returns(Promise.resolve(signature)),
-                Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
-            ];
-
-            const ecSignature = await zeroEx.signOrderHashAsync(
-                orderHash,
-                makerAddress,
-                SHOULD_ADD_PERSONAL_MESSAGE_PREFIX,
-            );
-            expect(ecSignature).to.deep.equal(expectedECSignature);
-        });
-        it('should return the correct ECSignature for signatureHex concatenated as V + R + S', async () => {
-            const orderHash = '0xc793e33ffded933b76f2f48d9aa3339fc090399d5e7f5dec8d3660f5480793f7';
-            const signature =
-                '0x1bc80bedc6756722672753413efdd749b5adbd4fd552595f59c13427407ee9aee02dea66f25a608bbae457e020fb6decb763deb8b7192abab624997242da248960';
-            const expectedECSignature = {
-                v: 27,
-                r: '0xc80bedc6756722672753413efdd749b5adbd4fd552595f59c13427407ee9aee0',
-                s: '0x2dea66f25a608bbae457e020fb6decb763deb8b7192abab624997242da248960',
-            };
-            stubs = [
-                Sinon.stub((zeroEx as any)._web3Wrapper, 'signMessageAsync').returns(Promise.resolve(signature)),
-                Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
-            ];
-
-            const ecSignature = await zeroEx.signOrderHashAsync(
-                orderHash,
-                makerAddress,
-                SHOULD_ADD_PERSONAL_MESSAGE_PREFIX,
-            );
-            expect(ecSignature).to.deep.equal(expectedECSignature);
-        });
-    });
     describe('#awaitTransactionMinedAsync', () => {
         beforeEach(async () => {
             await blockchainLifecycle.startAsync();

packages/0x.js/test/artifacts_test.ts

@@ -1,5 +1,6 @@
 import { web3Factory } from '@0xproject/dev-utils';
 import * as fs from 'fs';
+import 'make-promises-safe';
 
 import { ZeroEx } from '../src';
 

packages/0x.js/test/assert_test.ts

@@ -1,43 +0,0 @@
-import { web3Factory } from '@0xproject/dev-utils';
-import * as chai from 'chai';
-import 'mocha';
-
-import { ZeroEx } from '../src';
-import { assert } from '../src/utils/assert';
-
-import { constants } from './utils/constants';
-import { provider } from './utils/web3_wrapper';
-
-const expect = chai.expect;
-
-describe('Assertion library', () => {
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
-    const zeroEx = new ZeroEx(provider, config);
-    describe('#isSenderAddressHexAsync', () => {
-        it('throws when address is invalid', async () => {
-            const address = '0xdeadbeef';
-            const varName = 'address';
-            return expect(
-                assert.isSenderAddressAsync(varName, address, (zeroEx as any)._web3Wrapper),
-            ).to.be.rejectedWith(`Expected ${varName} to be of type ETHAddressHex, encountered: ${address}`);
-        });
-        it('throws when address is unavailable', async () => {
-            const validUnrelatedAddress = '0x8b0292b11a196601eddce54b665cafeca0347d42';
-            const varName = 'address';
-            return expect(
-                assert.isSenderAddressAsync(varName, validUnrelatedAddress, (zeroEx as any)._web3Wrapper),
-            ).to.be.rejectedWith(
-                `Specified ${varName} ${validUnrelatedAddress} isn't available through the supplied web3 provider`,
-            );
-        });
-        it("doesn't throw if address is available", async () => {
-            const availableAddress = (await zeroEx.getAvailableAddressesAsync())[0];
-            const varName = 'address';
-            return expect(
-                assert.isSenderAddressAsync(varName, availableAddress, (zeroEx as any)._web3Wrapper),
-            ).to.become(undefined);
-        });
-    });
-});

packages/0x.js/test/global_hooks.ts

@@ -0,0 +1,19 @@
+import { devConstants } from '@0xproject/dev-utils';
+import { runMigrationsAsync } from '@0xproject/migrations';
+import * as path from 'path';
+
+import { constants } from './utils/constants';
+import { provider } from './utils/web3_wrapper';
+
+before('migrate contracts', async function(): Promise<void> {
+    // HACK: Since the migrations take longer then our global mocha timeout limit
+    // we manually increase it for this before hook.
+    const mochaTestTimeoutMs = 20000;
+    this.timeout(mochaTestTimeoutMs);
+    const txDefaults = {
+        gas: devConstants.GAS_ESTIMATE,
+        from: devConstants.TESTRPC_FIRST_ADDRESS,
+    };
+    const artifactsDir = `../migrations/artifacts/1.0.0`;
+    await runMigrationsAsync(provider, artifactsDir, txDefaults);
+});

packages/0x.js/test/utils/chai_setup.ts

@@ -4,7 +4,7 @@ import ChaiBigNumber = require('chai-bignumber');
 import * as dirtyChai from 'dirty-chai';
 
 export const chaiSetup = {
-    configure() {
+    configure(): void {
         chai.config.includeStack = true;
         chai.use(ChaiBigNumber());
         chai.use(dirtyChai);

packages/0x.js/test/utils/deployer.ts

@@ -1,18 +0,0 @@
-import { Deployer } from '@0xproject/deployer';
-import { devConstants } from '@0xproject/dev-utils';
-import * as path from 'path';
-
-import { constants } from './constants';
-
-import { provider } from './web3_wrapper';
-
-const artifactsDir = path.resolve('test', 'artifacts');
-const deployerOpts = {
-    artifactsDir,
-    provider,
-    networkId: constants.TESTRPC_NETWORK_ID,
-    defaults: {
-        gas: devConstants.GAS_ESTIMATE,
-    },
-};
-export const deployer = new Deployer(deployerOpts);

packages/0x.js/test/utils/report_callback_errors.ts

@@ -1,66 +0,0 @@
-import * as chai from 'chai';
-import * as _ from 'lodash';
-
-import { DoneCallback } from '../../src/types';
-
-const expect = chai.expect;
-
-export const reportNoErrorCallbackErrors = (done: DoneCallback, expectToBeCalledOnce = true) => {
-    return <T>(f?: (value: T) => void) => {
-        const wrapped = (value: T) => {
-            if (_.isUndefined(f)) {
-                done();
-                return;
-            }
-            try {
-                f(value);
-                if (expectToBeCalledOnce) {
-                    done();
-                }
-            } catch (err) {
-                done(err);
-            }
-        };
-        return wrapped;
-    };
-};
-
-export const reportNodeCallbackErrors = (done: DoneCallback, expectToBeCalledOnce = true) => {
-    return <T>(f?: (value: T) => void) => {
-        const wrapped = (error: Error | null, value: T | undefined) => {
-            if (!_.isNull(error)) {
-                done(error);
-            } else {
-                if (_.isUndefined(f)) {
-                    done();
-                    return;
-                }
-                try {
-                    f(value as T);
-                    if (expectToBeCalledOnce) {
-                        done();
-                    }
-                } catch (err) {
-                    done(err);
-                }
-            }
-        };
-        return wrapped;
-    };
-};
-
-export const assertNodeCallbackError = (done: DoneCallback, errMsg: string) => {
-    const wrapped = <T>(error: Error | null, value: T | undefined) => {
-        if (_.isNull(error)) {
-            done(new Error('Expected callback to receive an error'));
-        } else {
-            try {
-                expect(error.message).to.be.equal(errMsg);
-                done();
-            } catch (err) {
-                done(err);
-            }
-        }
-    };
-    return wrapped;
-};

packages/0x.js/test/utils/token_utils.ts

@@ -1,6 +1,7 @@
+import { Token } from '@0xproject/types';
 import * as _ from 'lodash';
 
-import { InternalZeroExError, Token } from '../../src/types';
+import { InternalZeroExError } from '../../src/types';
 
 const PROTOCOL_TOKEN_SYMBOL = 'ZRX';
 const WETH_TOKEN_SYMBOL = 'WETH';

packages/0x.js/test/utils/web3_wrapper.ts

@@ -1,9 +1,6 @@
 import { devConstants, web3Factory } from '@0xproject/dev-utils';
 import { Provider } from '@0xproject/types';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import * as Web3 from 'web3';
-
-import { constants } from './constants';
 
 const web3 = web3Factory.create({ shouldUseInProcessGanache: true });
 const provider: Provider = web3.currentProvider;

packages/abi-gen/CHANGELOG.json

@@ -1,4 +1,32 @@
 [
+    {
+        "version": "0.3.0",
+        "changes": [
+            {
+                "note": "Properly export the executable binary",
+                "pr": 588
+            }
+        ],
+        "timestamp": 1527008270
+    },
+    {
+        "timestamp": 1525477860,
+        "version": "0.2.13",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1525428773,
+        "version": "0.2.12",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1524044013,
         "version": "0.2.11",

packages/abi-gen/CHANGELOG.md

@@ -5,11 +5,23 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v0.3.0 - _May 22, 2018_
+
+    * Properly export the executable binary (#588)
+
+## v0.2.13 - _May 4, 2018_
+
+    * Dependencies updated
+
+## v0.2.12 - _May 4, 2018_
+
+    * Dependencies updated
+
 ## v0.2.11 - _April 18, 2018_
 
     * Dependencies updated
 
-## v0.2.10 - _April 12, 2018_
+## v0.2.10 - _April 11, 2018_
 
     * Dependencies updated
 
@@ -21,26 +33,26 @@ CHANGELOG
 
     * Dependencies updated
 
-## v0.2.5 - _March 18, 2018_
+## v0.2.5 - _March 17, 2018_
 
     * Consolidate all `console.log` calls into `logUtils` in the `@0xproject/utils` package (#452)
 
-## v0.2.4 - _March 4, 2018_
+## v0.2.4 - _March 3, 2018_
 
     * Add a `backend` parameter that allows you to specify the Ethereum library you use in your templates (`web3` or `ethers`). Ethers auto-converts small ints to numbers whereas Web3 doesn't. Defaults to `web3` (#413)
     * Add support for [tuple types](https://solidity.readthedocs.io/en/develop/abi-spec.html#handling-tuple-types) (#413)
     * Add `hasReturnValue` to context data (#413)
 
-## v0.2.1 - _February 9, 2018_
+## v0.2.1 - _February 8, 2018_
 
     * Fix publishing issue where .npmignore was not properly excluding undesired content (#389)
 
-## v0.2.0 - _February 7, 2018_
+## v0.2.0 - _February 6, 2018_
 
     * Added CLI options for explicit specifying location of partials and main template (#346)
     * Added CLI option to specify networkId, adding support for the JSON artifact format found in @0xproject/contracts (#388)
 
-## v0.1.0 - _January 11, 2018_
+## v0.1.0 - _January 10, 2018_
 
     * Fixed array typings with union types (#295)
     * Add event ABIs to context data passed to templates (#302)

packages/abi-gen/README.md

@@ -80,28 +80,16 @@ yarn install
 
 ### Build
 
-If this is your **first** time building this package, you must first build **all** packages within the monorepo. This is because packages that depend on other packages located inside this monorepo are symlinked when run from **within** the monorepo. This allows you to make changes across multiple packages without first publishing dependent packages to NPM. To build all packages, run the following from the monorepo root directory:
+To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
 
 ```bash
-yarn lerna:rebuild
+PKG=@0xproject/abi-gen yarn build
 ```
 
 Or continuously rebuild on change:
 
 ```bash
-yarn dev
-```
-
-You can also build this specific package by running the following from within its directory:
-
-```bash
-yarn build
-```
-
-or continuously rebuild on change:
-
-```bash
-yarn build:watch
+PKG=@0xproject/abi-gen yarn watch
 ```
 
 ### Clean

packages/abi-gen/bin/abi-gen.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/index.js')

packages/abi-gen/package.json

@@ -1,18 +1,21 @@
 {
     "name": "@0xproject/abi-gen",
-    "version": "0.2.11",
+    "version": "0.2.13",
+    "engines": {
+        "node": ">=6.12"
+    },
     "description": "Generate contract wrappers from ABI and handlebars templates",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
     "scripts": {
-        "build:watch": "tsc -w",
-        "lint": "tslint --project . 'src/**/*.ts'",
+        "watch": "tsc -w",
+        "lint": "tslint --project .",
         "clean": "shx rm -rf lib scripts",
         "build": "tsc && copyfiles -u 2 './lib/monorepo_scripts/**/*' ./scripts",
         "manual:postpublish": "yarn build; node ./scripts/postpublish.js"
     },
     "bin": {
-        "abi-gen": "lib/index.js"
+        "abi-gen": "bin/abi-gen.js"
     },
     "repository": {
         "type": "git",
@@ -24,9 +27,9 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/packages/abi-gen/README.md",
     "dependencies": {
-        "@0xproject/types": "^0.6.1",
-        "@0xproject/typescript-typings": "^0.2.0",
-        "@0xproject/utils": "^0.5.2",
+        "@0xproject/types": "^0.6.3",
+        "@0xproject/typescript-typings": "^0.3.1",
+        "@0xproject/utils": "^0.6.1",
         "chalk": "^2.3.0",
         "glob": "^7.1.2",
         "handlebars": "^4.0.11",
@@ -36,14 +39,15 @@
         "yargs": "^10.0.3"
     },
     "devDependencies": {
-        "@0xproject/monorepo-scripts": "^0.1.18",
-        "@0xproject/tslint-config": "^0.4.16",
+        "@0xproject/monorepo-scripts": "^0.1.19",
+        "@0xproject/tslint-config": "^0.4.17",
         "@types/glob": "^5.0.33",
         "@types/handlebars": "^4.0.36",
         "@types/mkdirp": "^0.5.1",
         "@types/node": "^8.0.53",
         "@types/yargs": "^10.0.0",
         "copyfiles": "^1.2.0",
+        "make-promises-safe": "^1.1.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "tslint": "5.8.0",

packages/abi-gen/src/index.ts

@@ -61,14 +61,13 @@ const args = yargs
         'Full usage example',
     ).argv;
 
-function registerPartials(partialsGlob: string) {
+function registerPartials(partialsGlob: string): void {
     const partialTemplateFileNames = globSync(partialsGlob);
     logUtils.log(`Found ${chalk.green(`${partialTemplateFileNames.length}`)} ${chalk.bold('partial')} templates`);
     for (const partialTemplateFileName of partialTemplateFileNames) {
         const namedContent = utils.getNamedContent(partialTemplateFileName);
         Handlebars.registerPartial(namedContent.name, namedContent.content);
     }
-    return partialsGlob;
 }
 
 function writeOutputFile(name: string, renderedTsCode: string): void {
@@ -108,13 +107,13 @@ for (const abiFileName of abiFileNames) {
         ABI = parsedContent; // ABI file
     } else if (!_.isUndefined(parsedContent.abi)) {
         ABI = parsedContent.abi; // Truffle artifact
-    } else if (!_.isUndefined(parsedContent.networks) && !_.isUndefined(parsedContent.networks[args.networkId])) {
-        ABI = parsedContent.networks[args.networkId].abi; // 0x contracts package artifact
+    } else if (!_.isUndefined(parsedContent.compilerOutput.abi)) {
+        ABI = parsedContent.compilerOutput.abi; // 0x artifact
     }
     if (_.isUndefined(ABI)) {
         logUtils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`);
         logUtils.log(
-            `Please make sure your ABI file is either an array with ABI entries or a truffle artifact or 0x deployer artifact`,
+            `Please make sure your ABI file is either an array with ABI entries or a truffle artifact or 0x sol-compiler artifact`,
         );
         process.exit(1);
     }

packages/assert/CHANGELOG.json

@@ -1,4 +1,31 @@
 [
+    {
+        "timestamp": 1527008270,
+        "version": "0.2.10",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1525477860,
+        "version": "0.2.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1525428773,
+        "version": "0.2.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1524044013,
         "version": "0.2.7",

packages/assert/CHANGELOG.md

@@ -5,11 +5,23 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v0.2.10 - _May 22, 2018_
+
+    * Dependencies updated
+
+## v0.2.9 - _May 4, 2018_
+
+    * Dependencies updated
+
+## v0.2.8 - _May 4, 2018_
+
+    * Dependencies updated
+
 ## v0.2.7 - _April 18, 2018_
 
     * Dependencies updated
 
-## v0.2.6 - _April 12, 2018_
+## v0.2.6 - _April 11, 2018_
 
     * Dependencies updated
 
@@ -21,20 +33,20 @@ CHANGELOG
 
     * Dependencies updated
 
-## v0.2.0 - _March 8, 2018_
+## v0.2.0 - _March 7, 2018_
 
     * Rename `isHttpUrl` to `isWebUri` (#412)
 
-## v0.1.0 - _March 4, 2018_
+## v0.1.0 - _March 3, 2018_
 
     * Remove isETHAddressHex checksum address check and assume address will be lowercased  (#373)
     * Add an optional parameter `subSchemas` to `doesConformToSchema` method (#385)
 
-## v0.0.18 - _February 9, 2017_
+## v0.0.18 - _February 8, 2017_
 
     * Fix publishing issue where .npmignore was not properly excluding undesired content (#389)
 
-## v0.0.4 - _November 14, 2017_
+## v0.0.4 - _November 13, 2017_
 
     * Re-publish Assert previously published under NPM package @0xproject/0x-assert
     * Added assertion isValidBaseUnitAmount which checks both that the value is a valid bigNumber and that it does not contain decimals.

packages/assert/README.md

@@ -46,28 +46,16 @@ yarn install
 
 ### Build
 
-If this is your **first** time building this package, you must first build **all** packages within the monorepo. This is because packages that depend on other packages located inside this monorepo are symlinked when run from **within** the monorepo. This allows you to make changes across multiple packages without first publishing dependent packages to NPM. To build all packages, run the following from the monorepo root directory:
+To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
 
 ```bash
-yarn lerna:rebuild
+PKG=@0xproject/assert yarn build
 ```
 
 Or continuously rebuild on change:
 
 ```bash
-yarn dev
-```
-
-You can also build this specific package by running the following from within its directory:
-
-```bash
-yarn build
-```
-
-or continuously rebuild on change:
-
-```bash
-yarn build:watch
+PKG=@0xproject/assert yarn watch
 ```
 
 ### Clean

packages/assert/package.json

@@ -1,14 +1,17 @@
 {
     "name": "@0xproject/assert",
-    "version": "0.2.7",
+    "version": "0.2.9",
+    "engines": {
+        "node": ">=6.12"
+    },
     "description": "Provides a standard way of performing type and schema validation across 0x projects",
     "main": "lib/src/index.js",
     "types": "lib/src/index.d.ts",
     "scripts": {
-        "build:watch": "tsc -w",
+        "watch": "tsc -w",
         "build": "tsc && copyfiles -u 3 './lib/src/monorepo_scripts/**/*' ./scripts",
         "clean": "shx rm -rf lib test_temp scripts",
-        "lint": "tslint --project . 'src/**/*.ts' 'test/**/*.ts'",
+        "lint": "tslint --project .",
         "run_mocha": "mocha lib/test/**/*_test.js --exit",
         "prepublishOnly": "run-p build",
         "test": "run-s clean build run_mocha",
@@ -27,14 +30,15 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/packages/assert/README.md",
     "devDependencies": {
-        "@0xproject/monorepo-scripts": "^0.1.18",
-        "@0xproject/tslint-config": "^0.4.16",
+        "@0xproject/monorepo-scripts": "^0.1.19",
+        "@0xproject/tslint-config": "^0.4.17",
         "@types/lodash": "4.14.104",
         "@types/mocha": "^2.2.42",
         "@types/valid-url": "^1.0.2",
         "chai": "^4.0.1",
         "copyfiles": "^1.2.0",
         "dirty-chai": "^2.0.1",
+        "make-promises-safe": "^1.1.0",
         "mocha": "^4.0.1",
         "npm-run-all": "^4.1.2",
         "nyc": "^11.0.1",
@@ -43,9 +47,9 @@
         "typescript": "2.7.1"
     },
     "dependencies": {
-        "@0xproject/json-schemas": "^0.7.21",
-        "@0xproject/typescript-typings": "^0.2.0",
-        "@0xproject/utils": "^0.5.2",
+        "@0xproject/json-schemas": "^0.7.23",
+        "@0xproject/typescript-typings": "^0.3.1",
+        "@0xproject/utils": "^0.6.1",
         "lodash": "^4.17.4",
         "valid-url": "^1.0.9"
     },

packages/assert/src/index.ts

@@ -10,7 +10,7 @@ export const assert = {
         const isBigNumber = _.isObject(value) && (value as any).isBigNumber;
         this.assert(isBigNumber, this.typeAssertionMessage(variableName, 'BigNumber', value));
     },
-    isValidBaseUnitAmount(variableName: string, value: BigNumber) {
+    isValidBaseUnitAmount(variableName: string, value: BigNumber): void {
         assert.isBigNumber(variableName, value);
         const isNegative = value.lessThan(0);
         this.assert(!isNegative, `${variableName} cannot be a negative number, found value: ${value.toNumber()}`);

packages/assert/test/assert_test.ts

@@ -2,6 +2,7 @@ import { schemas } from '@0xproject/json-schemas';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
 import * as dirtyChai from 'dirty-chai';
+import 'make-promises-safe';
 import 'mocha';
 
 import { assert } from '../src/index';
@@ -10,6 +11,7 @@ chai.config.includeStack = true;
 chai.use(dirtyChai);
 const expect = chai.expect;
 
+// tslint:disable:custom-no-magic-numbers
 describe('Assertions', () => {
     const variableName = 'variable';
     describe('#isBigNumber', () => {
@@ -251,3 +253,4 @@ describe('Assertions', () => {
         });
     });
 });
+// tslint:enable:custom-no-magic-numbers

packages/base-contract/CHANGELOG.json

@@ -1,4 +1,32 @@
 [
+    {
+        "timestamp": 1527008270,
+        "version": "0.3.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1525477860,
+        "version": "0.3.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "0.3.0",
+        "changes": [
+            {
+                "note": "Update ethers-contracts to ethers.js",
+                "pr": 540
+            }
+        ],
+        "timestamp": 1525428773
+    },
     {
         "timestamp": 1524044013,
         "version": "0.2.1",

packages/base-contract/CHANGELOG.md

@@ -5,11 +5,23 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v0.3.2 - _May 22, 2018_
+
+    * Dependencies updated
+
+## v0.3.1 - _May 4, 2018_
+
+    * Dependencies updated
+
+## v0.3.0 - _May 4, 2018_
+
+    * Update ethers-contracts to ethers.js (#540)
+
 ## v0.2.1 - _April 18, 2018_
 
     * Dependencies updated
 
-## v0.2.0 - _April 12, 2018_
+## v0.2.0 - _April 11, 2018_
 
     * Contract wrappers now accept Provider and defaults instead of Web3Wrapper (#501)
 
@@ -23,6 +35,6 @@ CHANGELOG
 
     * Dependencies updated
 
-## v0.0.2 - _March 4, 2018_
+## v0.0.2 - _March 3, 2018_
 
     * Initial release

packages/base-contract/README.md

@@ -44,14 +44,16 @@ yarn install
 
 ### Build
 
+To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
+
 ```bash
-yarn build
+PKG=@0xproject/base-contract yarn build
 ```
 
-or
+Or continuously rebuild on change:
 
 ```bash
-yarn build:watch
+PKG=@0xproject/base-contract yarn watch
 ```
 
 ### Lint

packages/base-contract/package.json

@@ -1,11 +1,14 @@
 {
     "name": "@0xproject/base-contract",
-    "version": "0.2.1",
+    "version": "0.3.1",
+    "engines": {
+        "node": ">=6.12"
+    },
     "description": "0x Base TS contract",
     "main": "lib/src/index.js",
     "types": "lib/src/index.d.ts",
     "scripts": {
-        "build:watch": "tsc -w",
+        "watch": "tsc -w",
         "build": "tsc && copyfiles -u 2 './lib/monorepo_scripts/**/*' ./scripts",
         "clean": "shx rm -rf lib scripts",
         "test": "run-s clean build run_mocha",
@@ -26,11 +29,12 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/packages/base-contract/README.md",
     "devDependencies": {
-        "@0xproject/monorepo-scripts": "^0.1.18",
-        "@0xproject/tslint-config": "^0.4.16",
+        "@0xproject/monorepo-scripts": "^0.1.19",
+        "@0xproject/tslint-config": "^0.4.17",
         "@types/lodash": "4.14.104",
         "chai": "^4.0.1",
         "copyfiles": "^1.2.0",
+        "make-promises-safe": "^1.1.0",
         "mocha": "^4.0.1",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
@@ -38,11 +42,11 @@
         "typescript": "2.7.1"
     },
     "dependencies": {
-        "@0xproject/types": "^0.6.1",
-        "@0xproject/typescript-typings": "^0.2.0",
-        "@0xproject/utils": "^0.5.2",
-        "@0xproject/web3-wrapper": "^0.6.1",
-        "ethers-contracts": "^2.2.1",
+        "@0xproject/types": "^0.6.3",
+        "@0xproject/typescript-typings": "^0.3.1",
+        "@0xproject/utils": "^0.6.1",
+        "@0xproject/web3-wrapper": "^0.6.3",
+        "ethers": "^3.0.15",
         "lodash": "^4.17.4"
     },
     "publishConfig": {

packages/base-contract/src/index.ts

@@ -1,6 +1,7 @@
 import {
     AbiDefinition,
     AbiType,
+    ConstructorAbi,
     ContractAbi,
     DataItem,
     MethodAbi,
@@ -10,13 +11,13 @@ import {
 } from '@0xproject/types';
 import { abiUtils, BigNumber } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import * as ethersContracts from 'ethers-contracts';
+import * as ethers from 'ethers';
 import * as _ from 'lodash';
 
 import { formatABIDataItem } from './utils';
 
 export interface EthersInterfaceByFunctionSignature {
-    [key: string]: ethersContracts.Interface;
+    [key: string]: ethers.Interface;
 }
 
 export class BaseContract {
@@ -24,6 +25,8 @@ export class BaseContract {
     protected _web3Wrapper: Web3Wrapper;
     public abi: ContractAbi;
     public address: string;
+    public contractName: string;
+    public constructorArgs: any[] = [];
     protected static _formatABIDataItemList(
         abis: DataItem[],
         values: any[],
@@ -37,11 +40,31 @@ export class BaseContract {
     protected static _bigNumberToString(type: string, value: any): any {
         return _.isObject(value) && value.isBigNumber ? value.toString() : value;
     }
+    protected static _lookupConstructorAbi(abi: ContractAbi): ConstructorAbi {
+        const constructorAbiIfExists = _.find(
+            abi,
+            (abiDefinition: AbiDefinition) => abiDefinition.type === AbiType.Constructor,
+        ) as ConstructorAbi | undefined;
+        if (!_.isUndefined(constructorAbiIfExists)) {
+            return constructorAbiIfExists;
+        } else {
+            // If the constructor is not explicitly defined, it won't be included in the ABI. It is
+            // still callable however, so we construct what the ABI would look like were it to exist.
+            const defaultConstructorAbi: ConstructorAbi = {
+                type: AbiType.Constructor,
+                stateMutability: 'nonpayable',
+                payable: false,
+                inputs: [],
+            };
+            return defaultConstructorAbi;
+        }
+    }
     protected static _bnToBigNumber(type: string, value: any): any {
         return _.isObject(value) && value._bn ? new BigNumber(value.toString()) : value;
     }
-    protected async _applyDefaultsToTxDataAsync<T extends Partial<TxData | TxDataPayable>>(
+    protected static async _applyDefaultsToTxDataAsync<T extends Partial<TxData | TxDataPayable>>(
         txData: T,
+        txDefaults: Partial<TxData>,
         estimateGasAsync?: (txData: T) => Promise<number>,
     ): Promise<TxData> {
         // Gas amount sourced with the following priorities:
@@ -49,20 +72,19 @@ export class BaseContract {
         // 2. Global config passed in at library instantiation
         // 3. Gas estimate calculation + safety margin
         const removeUndefinedProperties = _.pickBy;
-        const txDataWithDefaults = ({
-            to: this.address,
-            ...removeUndefinedProperties(this._web3Wrapper.getContractDefaults()),
+        const txDataWithDefaults: TxData = {
+            ...removeUndefinedProperties(txDefaults),
             ...removeUndefinedProperties(txData as any),
             // HACK: TS can't prove that T is spreadable.
             // Awaiting https://github.com/Microsoft/TypeScript/pull/13288 to be merged
-        } as any) as TxData;
+        } as any;
         if (_.isUndefined(txDataWithDefaults.gas) && !_.isUndefined(estimateGasAsync)) {
             const estimatedGas = await estimateGasAsync(txData);
             txDataWithDefaults.gas = estimatedGas;
         }
         return txDataWithDefaults;
     }
-    protected _lookupEthersInterface(functionSignature: string): ethersContracts.Interface {
+    protected _lookupEthersInterface(functionSignature: string): ethers.Interface {
         const ethersInterface = this._ethersInterfacesByFunctionSignature[functionSignature];
         if (_.isUndefined(ethersInterface)) {
             throw new Error(`Failed to lookup method with function signature '${functionSignature}'`);
@@ -82,8 +104,15 @@ export class BaseContract {
         }) as MethodAbi;
         return methodAbi;
     }
-    constructor(abi: ContractAbi, address: string, provider: Provider, defaults?: Partial<TxData>) {
-        this._web3Wrapper = new Web3Wrapper(provider, defaults);
+    constructor(
+        contractName: string,
+        abi: ContractAbi,
+        address: string,
+        provider: Provider,
+        txDefaults?: Partial<TxData>,
+    ) {
+        this.contractName = contractName;
+        this._web3Wrapper = new Web3Wrapper(provider, txDefaults);
         this.abi = abi;
         this.address = address;
         const methodAbis = this.abi.filter(
@@ -92,7 +121,7 @@ export class BaseContract {
         this._ethersInterfacesByFunctionSignature = {};
         _.each(methodAbis, methodAbi => {
             const functionSignature = abiUtils.getFunctionSignature(methodAbi);
-            this._ethersInterfacesByFunctionSignature[functionSignature] = new ethersContracts.Interface([methodAbi]);
+            this._ethersInterfacesByFunctionSignature[functionSignature] = new ethers.Interface([methodAbi]);
         });
     }
 }

packages/base-contract/test/utils_test.ts

@@ -1,5 +1,6 @@
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
+import 'make-promises-safe';
 import 'mocha';
 
 import { formatABIDataItem } from '../src/utils';

packages/connect/CHANGELOG.json

@@ -1,4 +1,31 @@
 [
+    {
+        "timestamp": 1527008270,
+        "version": "0.6.13",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1525477860,
+        "version": "0.6.12",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1525428773,
+        "version": "0.6.11",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1524044013,
         "version": "0.6.10",

packages/connect/CHANGELOG.md

@@ -5,11 +5,23 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v0.6.13 - _May 22, 2018_
+
+    * Dependencies updated
+
+## v0.6.12 - _May 4, 2018_
+
+    * Dependencies updated
+
+## v0.6.11 - _May 4, 2018_
+
+    * Dependencies updated
+
 ## v0.6.10 - _April 18, 2018_
 
     * Dependencies updated
 
-## v0.6.9 - _April 12, 2018_
+## v0.6.9 - _April 11, 2018_
 
     * Dependencies updated
 
@@ -21,44 +33,44 @@ CHANGELOG
 
     * Dependencies updated
 
-## v0.6.4 - _March 18, 2018_
+## v0.6.4 - _March 17, 2018_
 
     * Consolidate `Order`, `SignedOrder`, and `ECSignature` into the `@0xproject/types` package (#456)
 
-## v0.6.2 - _February 16, 2018_
+## v0.6.2 - _February 15, 2018_
 
     * Fix JSON parse empty response (#407)
 
-## v0.6.0 - _February 16, 2018_
+## v0.6.0 - _February 15, 2018_
 
     * Add pagination options to HttpClient methods (#393)
     * Add heartbeat configuration to WebSocketOrderbookChannel constructor (#406)
 
-## v0.5.7 - _February 9, 2018_
+## v0.5.7 - _February 8, 2018_
 
     * Fix publishing issue where .npmignore was not properly excluding undesired content (#389)
 
-## v0.5.0 - _January 17, 2018_
+## v0.5.0 - _January 16, 2018_
 
     * Sanitize api endpoint url and remove trailing slashes (#318)
     * Improve error message text in HttpClient (#318)
     * Stop appending '/v0' to api endpoint url in HttpClient (#318)
 
-## v0.4.0 - _January 11, 2018_
+## v0.4.0 - _January 10, 2018_
 
     * Prevent getFeesAsync method on HttpClient from mutating input (#296)
 
-## v0.3.0 - _December 8, 2017_
+## v0.3.0 - _December 7, 2017_
 
     * Expose WebSocketOrderbookChannel and associated types to public interface (#251)
     * Remove tokenA and tokenB fields from OrdersRequest (#256)
 
-## v0.2.0 - _November 29, 2017_
+## v0.2.0 - _November 28, 2017_
 
     * Add SignedOrder and TokenTradeInfo to the public interface
     * Add ECSignature and Order to the public interface
     * Remove dependency on 0x.js
 
-## v0.1.0 - _November 22, 2017_
+## v0.1.0 - _November 21, 2017_
 
     * Provide a HttpClient class for interacting with standard relayer api compliant HTTP urls

packages/connect/README.md

@@ -43,28 +43,16 @@ yarn install
 
 ### Build
 
-If this is your **first** time building this package, you must first build **all** packages within the monorepo. This is because packages that depend on other packages located inside this monorepo are symlinked when run from **within** the monorepo. This allows you to make changes across multiple packages without first publishing dependent packages to NPM. To build all packages, run the following from the monorepo root directory:
+To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
 
 ```bash
-yarn lerna:rebuild
+PKG=@0xproject/connect yarn build
 ```
 
 Or continuously rebuild on change:
 
 ```bash
-yarn dev
-```
-
-You can also build this specific package by running the following from within its directory:
-
-```bash
-yarn build
-```
-
-or continuously rebuild on change:
-
-```bash
-yarn build:watch
+PKG=@0xproject/connect yarn watch
 ```
 
 ### Clean

packages/connect/package.json

@@ -1,6 +1,9 @@
 {
     "name": "@0xproject/connect",
-    "version": "0.6.10",
+    "version": "0.6.12",
+    "engines": {
+        "node": ">=6.12"
+    },
     "description": "A javascript library for interacting with the standard relayer api",
     "keywords": [
         "connect",
@@ -12,18 +15,18 @@
     "main": "lib/src/index.js",
     "types": "lib/src/index.d.ts",
     "scripts": {
-        "build:watch": "tsc -w",
+        "watch": "tsc -w",
         "build": "tsc && copyfiles -u 3 './lib/src/monorepo_scripts/**/*' ./scripts",
         "clean": "shx rm -rf lib test_temp scripts",
         "copy_test_fixtures": "copyfiles -u 2 './test/fixtures/**/*.json' ./lib/test/fixtures",
-        "lint": "tslint --project . 'src/**/*.ts' 'test/**/*.ts'",
+        "lint": "tslint --project .",
         "run_mocha": "mocha lib/test/**/*_test.js --exit",
         "test": "run-s clean build copy_test_fixtures run_mocha",
         "test:coverage": "nyc npm run test --all && yarn coverage:report:lcov",
         "coverage:report:lcov": "nyc report --reporter=text-lcov > coverage/lcov.info",
         "test:circleci": "yarn test:coverage",
         "manual:postpublish": "yarn build; node ./scripts/postpublish.js",
-        "docs:stage": "yarn build && node ./scripts/stage_docs.js",
+        "docs:stage": "node scripts/stage_docs.js",
         "docs:json": "typedoc --excludePrivate --excludeExternals --target ES5 --json $JSON_FILE_PATH $PROJECT_FILES",
         "upload_docs_json": "aws s3 cp generated_docs/index.json $S3_URL --profile 0xproject --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers --content-type application/json"
     },
@@ -42,27 +45,24 @@
     },
     "author": "Brandon Millman",
     "license": "Apache-2.0",
-    "engines": {
-        "node": ">=6.0.0"
-    },
     "bugs": {
         "url": "https://github.com/0xProject/0x-monorepo/issues"
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/packages/connect/README.md",
     "dependencies": {
-        "@0xproject/assert": "^0.2.7",
-        "@0xproject/json-schemas": "^0.7.21",
-        "@0xproject/types": "^0.6.1",
-        "@0xproject/typescript-typings": "^0.2.0",
-        "@0xproject/utils": "^0.5.2",
+        "@0xproject/assert": "^0.2.9",
+        "@0xproject/json-schemas": "^0.7.23",
+        "@0xproject/types": "^0.6.3",
+        "@0xproject/typescript-typings": "^0.3.1",
+        "@0xproject/utils": "^0.6.1",
         "isomorphic-fetch": "^2.2.1",
         "lodash": "^4.17.4",
         "query-string": "^5.0.1",
         "websocket": "^1.0.25"
     },
     "devDependencies": {
-        "@0xproject/monorepo-scripts": "^0.1.18",
-        "@0xproject/tslint-config": "^0.4.16",
+        "@0xproject/monorepo-scripts": "^0.1.19",
+        "@0xproject/tslint-config": "^0.4.17",
         "@types/fetch-mock": "^5.12.1",
         "@types/lodash": "4.14.104",
         "@types/mocha": "^2.2.42",
@@ -74,6 +74,7 @@
         "copyfiles": "^1.2.0",
         "dirty-chai": "^2.0.1",
         "fetch-mock": "^5.13.1",
+        "make-promises-safe": "^1.1.0",
         "mocha": "^4.0.1",
         "npm-run-all": "^4.1.2",
         "nyc": "^11.0.1",

packages/connect/src/ws_orderbook_channel.ts

@@ -91,7 +91,7 @@ export class WebSocketOrderbookChannel implements OrderbookChannel {
     /**
      * Close the websocket and stop receiving updates
      */
-    public close() {
+    public close(): void {
         if (!_.isUndefined(this._connectionIfExists)) {
             this._connectionIfExists.close();
         }
@@ -99,7 +99,7 @@ export class WebSocketOrderbookChannel implements OrderbookChannel {
             clearInterval(this._heartbeatTimerIfExists);
         }
     }
-    private _getConnection(callback: (error?: Error, connection?: WebSocket.connection) => void) {
+    private _getConnection(callback: (error?: Error, connection?: WebSocket.connection) => void): void {
         if (!_.isUndefined(this._connectionIfExists) && this._connectionIfExists.connected) {
             callback(undefined, this._connectionIfExists);
         } else {

packages/connect/test/http_client_test.ts

@@ -3,6 +3,7 @@ import * as chai from 'chai';
 import * as chaiAsPromised from 'chai-as-promised';
 import * as dirtyChai from 'dirty-chai';
 import * as fetchMock from 'fetch-mock';
+import 'make-promises-safe';
 import 'mocha';
 
 import { HttpClient } from '../src/index';

packages/connect/test/orderbook_channel_message_parsers_test.ts

@@ -1,5 +1,6 @@
 import * as chai from 'chai';
 import * as dirtyChai from 'dirty-chai';
+import 'make-promises-safe';
 import 'mocha';
 
 import { orderbookChannelMessageParser } from '../src/utils/orderbook_channel_message_parser';

packages/connect/test/ws_orderbook_channel_test.ts

@@ -1,6 +1,7 @@
 import * as chai from 'chai';
 import * as dirtyChai from 'dirty-chai';
 import * as _ from 'lodash';
+import 'make-promises-safe';
 import 'mocha';
 
 import { WebSocketOrderbookChannel } from '../src/ws_orderbook_channel';

packages/contract-wrappers/.npmignore

@@ -0,0 +1,11 @@
+.*
+tsconfig.json
+webpack.config.js
+yarn-error.log
+test/
+/src/
+/_bundles/
+/contract_templates/
+/generated_docs/
+/scripts/
+/lib/src/monorepo_scripts/

packages/contract-wrappers/CHANGELOG.json

@@ -0,0 +1,21 @@
+[
+    {
+        "version": "0.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ],
+        "timestamp": 1527008544
+    },
+    {
+        "timestamp": 1527008270,
+        "version": "0.0.1",
+        "changes": [
+            {
+                "note": "Moved contractWrappers out of 0x.js",
+                "pr": 579
+            }
+        ]
+    }
+]

packages/contract-wrappers/CHANGELOG.md

@@ -0,0 +1,14 @@
+<!--
+This file is auto-generated using the monorepo-scripts package. Don't edit directly.
+Edit the package's CHANGELOG.json file only.
+-->
+
+CHANGELOG
+
+## v0.0.2 - _May 22, 2018_
+
+    * Dependencies updated
+
+## v0.0.1 - _May 22, 2018_
+
+    * Moved contractWrappers out of 0x.js (#579)

packages/contract-wrappers/README.md

@@ -0,0 +1,89 @@
+## @0xproject/contract-wrappers
+
+Smart TS wrappers for 0x smart contracts. The wrappers have simplified interfaces, perform client-side validation on transactions and throw helpful error messages.
+
+### Read the [Documentation](https://0xproject.com/docs/0x.js).
+
+## Installation
+
+**Install**
+
+```bash
+npm install @0xproject/contract-wrappers --save
+```
+
+**Import**
+
+```javascript
+import { ContractWrappers } from '@0xproject/contract-wrappers';
+```
+
+If your project is in [TypeScript](https://www.typescriptlang.org/), add the following to your `tsconfig.json`:
+
+```json
+"compilerOptions": {
+    "typeRoots": ["node_modules/@0xproject/typescript-typings/types", "node_modules/@types"],
+}
+```
+
+## Contributing
+
+We strongly recommend that the community help us make improvements and determine the future direction of the protocol. To report bugs within this package, please create an issue in this repository.
+
+Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.
+
+### Install dependencies
+
+If you don't have yarn workspaces enabled (Yarn < v1.0) - enable them:
+
+```bash
+yarn config set workspaces-experimental true
+```
+
+Then install dependencies
+
+```bash
+yarn install
+```
+
+### Build
+
+To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
+
+```bash
+PKG=@0xproject/contract-wrappers yarn build
+```
+
+Or continuously rebuild on change:
+
+```bash
+PKG=@0xproject/contract-wrappers yarn watch
+```
+
+```bash
+yarn build
+```
+
+or continuously rebuild on change:
+
+```bash
+yarn watch
+```
+
+### Clean
+
+```bash
+yarn clean
+```
+
+### Lint
+
+```bash
+yarn lint
+```
+
+### Run Tests
+
+```bash
+yarn test
+```

packages/contract-wrappers/package.json

@@ -0,0 +1,98 @@
+{
+    "name": "@0xproject/contract-wrappers",
+    "version": "0.0.1",
+    "description": "Smart TS wrappers for 0x smart contracts",
+    "keywords": [
+        "0xproject",
+        "ethereum",
+        "tokens",
+        "exchange"
+    ],
+    "main": "lib/src/index.js",
+    "types": "lib/src/index.d.ts",
+    "scripts": {
+        "watch": "tsc -w",
+        "prebuild": "run-s clean generate_contract_wrappers",
+        "generate_contract_wrappers": "abi-gen --abis 'src/compact_artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry|DummyToken).json' --template ../contract_templates/contract.handlebars --partials '../contract_templates/partials/**/*.handlebars' --output src/contract_wrappers/generated --backend ethers && prettier --write 'src/contract_wrappers/generated/**.ts'",
+        "lint": "tslint --project .",
+        "test:circleci": "run-s test:coverage",
+        "test": "run-s clean build run_mocha",
+        "test:coverage": "nyc npm run test --all && yarn coverage:report:lcov",
+        "coverage:report:lcov": "nyc report --reporter=text-lcov > coverage/lcov.info",
+        "update_artifacts": "for i in ${npm_package_config_contracts}; do copyfiles -u 4 ../migrations/artifacts/1.0.0/$i.json test/artifacts; done;",
+        "clean": "shx rm -rf _bundles lib test_temp scripts test/artifacts src/contract_wrappers/generated",
+        "build": "tsc && yarn update_artifacts && copyfiles -u 2 './src/compact_artifacts/**/*.json' ./lib/src/compact_artifacts && copyfiles -u 3 './lib/src/monorepo_scripts/**/*' ./scripts",
+        "run_mocha": "mocha lib/test/**/*_test.js lib/test/global_hooks.js --timeout 10000 --bail --exit",
+        "manual:postpublish": "yarn build; node ./scripts/postpublish.js"
+    },
+    "config": {
+        "compact_artifacts": "Exchange DummyToken ZRXToken Token EtherToken TokenTransferProxy TokenRegistry",
+        "contracts": "Exchange DummyToken ZRXToken Token WETH9 TokenTransferProxy MultiSigWallet MultiSigWalletWithTimeLock MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress MaliciousToken TokenRegistry Arbitrage EtherDelta AccountLevels",
+        "postpublish": {
+            "assets": [
+                "packages/contract-wrappers/_bundles/index.js",
+                "packages/contract-wrappers/_bundles/index.min.js"
+            ]
+        }
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/0xProject/0x-monorepo"
+    },
+    "license": "Apache-2.0",
+    "engines": {
+        "node": ">=6.0.0"
+    },
+    "devDependencies": {
+        "@0xproject/abi-gen": "^0.2.13",
+        "@0xproject/dev-utils": "^0.4.1",
+        "@0xproject/migrations": "^0.0.5",
+        "@0xproject/monorepo-scripts": "^0.1.19",
+        "@0xproject/sol-compiler": "^0.4.3",
+        "@0xproject/subproviders": "^0.10.1",
+        "@0xproject/tslint-config": "^0.4.17",
+        "@types/lodash": "4.14.104",
+        "@types/mocha": "^2.2.42",
+        "@types/node": "^8.0.53",
+        "@types/sinon": "^2.2.2",
+        "@types/uuid": "^3.4.2",
+        "awesome-typescript-loader": "^3.1.3",
+        "chai": "^4.0.1",
+        "chai-as-promised": "^7.1.0",
+        "chai-bignumber": "^2.0.1",
+        "copyfiles": "^1.2.0",
+        "dirty-chai": "^2.0.1",
+        "make-promises-safe": "^1.1.0",
+        "mocha": "^4.0.1",
+        "npm-run-all": "^4.1.2",
+        "nyc": "^11.0.1",
+        "opn-cli": "^3.1.0",
+        "prettier": "^1.11.1",
+        "shx": "^0.2.2",
+        "sinon": "^4.0.0",
+        "source-map-support": "^0.5.0",
+        "tslint": "5.8.0",
+        "typescript": "2.7.1",
+        "web3-provider-engine": "^14.0.4"
+    },
+    "dependencies": {
+        "@0xproject/assert": "^0.2.9",
+        "@0xproject/base-contract": "^0.3.1",
+        "@0xproject/fill-scenarios": "^0.0.1",
+        "@0xproject/json-schemas": "^0.7.23",
+        "@0xproject/order-utils": "^0.0.4",
+        "@0xproject/types": "^0.6.3",
+        "@0xproject/typescript-typings": "^0.3.1",
+        "@0xproject/utils": "^0.6.1",
+        "@0xproject/web3-wrapper": "^0.6.3",
+        "ethereumjs-blockstream": "^2.0.6",
+        "ethereumjs-util": "^5.1.1",
+        "ethers": "^3.0.15",
+        "js-sha3": "^0.7.0",
+        "lodash": "^4.17.4",
+        "uuid": "^3.1.0"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

packages/contract-wrappers/src/artifacts.ts

@@ -0,0 +1,18 @@
+import { Artifact } from '@0xproject/types';
+
+import * as DummyToken from './compact_artifacts/DummyToken.json';
+import * as EtherToken from './compact_artifacts/EtherToken.json';
+import * as Exchange from './compact_artifacts/Exchange.json';
+import * as Token from './compact_artifacts/Token.json';
+import * as TokenRegistry from './compact_artifacts/TokenRegistry.json';
+import * as TokenTransferProxy from './compact_artifacts/TokenTransferProxy.json';
+import * as ZRX from './compact_artifacts/ZRX.json';
+export const artifacts = {
+    ZRX: (ZRX as any) as Artifact,
+    DummyToken: (DummyToken as any) as Artifact,
+    Token: (Token as any) as Artifact,
+    Exchange: (Exchange as any) as Artifact,
+    EtherToken: (EtherToken as any) as Artifact,
+    TokenRegistry: (TokenRegistry as any) as Artifact,
+    TokenTransferProxy: (TokenTransferProxy as any) as Artifact,
+};

packages/contract-wrappers/src/compact_artifacts/DummyToken.json

@@ -0,0 +1,22 @@
+{
+    "contract_name": "DummyToken",
+    "abi": [
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_target",
+                    "type": "address"
+                },
+                {
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "setBalance",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        }
+    ]
+}

packages/contract-wrappers/src/compact_artifacts/EtherToken.json

@@ -0,0 +1,287 @@
+{
+    "contract_name": "EtherToken",
+    "abi": [
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "name",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "string"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_spender",
+                    "type": "address"
+                },
+                {
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "approve",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "totalSupply",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_from",
+                    "type": "address"
+                },
+                {
+                    "name": "_to",
+                    "type": "address"
+                },
+                {
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "transferFrom",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "amount",
+                    "type": "uint256"
+                }
+            ],
+            "name": "withdraw",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "decimals",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "uint8"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "_owner",
+                    "type": "address"
+                }
+            ],
+            "name": "balanceOf",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "symbol",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "string"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_to",
+                    "type": "address"
+                },
+                {
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "transfer",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [],
+            "name": "deposit",
+            "outputs": [],
+            "payable": true,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "_owner",
+                    "type": "address"
+                },
+                {
+                    "name": "_spender",
+                    "type": "address"
+                }
+            ],
+            "name": "allowance",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "payable": true,
+            "type": "fallback"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "_from",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "name": "_to",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "Transfer",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "_owner",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "name": "_spender",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "Approval",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "_owner",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "Deposit",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "_owner",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "Withdrawal",
+            "type": "event"
+        }
+    ],
+    "networks": {
+        "1": {
+            "address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+        },
+        "3": {
+            "address": "0xc00fd9820cd2898cc4c054b7bf142de637ad129a"
+        },
+        "4": {
+            "address": "0xc778417e063141139fce010982780140aa0cd5ab"
+        },
+        "42": {
+            "address": "0x653e49e301e508a13237c0ddc98ae7d4cd2667a1"
+        },
+        "50": {
+            "address": "0x871dd7c2b4b25e1aa18728e9d5f2af4c4e431f5c"
+        }
+    }
+}

packages/contract-wrappers/src/compact_artifacts/Exchange.json

@@ -0,0 +1,610 @@
+{
+    "contract_name": "Exchange",
+    "abi": [
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "numerator",
+                    "type": "uint256"
+                },
+                {
+                    "name": "denominator",
+                    "type": "uint256"
+                },
+                {
+                    "name": "target",
+                    "type": "uint256"
+                }
+            ],
+            "name": "isRoundingError",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "filled",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "cancelled",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "orderAddresses",
+                    "type": "address[5][]"
+                },
+                {
+                    "name": "orderValues",
+                    "type": "uint256[6][]"
+                },
+                {
+                    "name": "fillTakerTokenAmount",
+                    "type": "uint256"
+                },
+                {
+                    "name": "shouldThrowOnInsufficientBalanceOrAllowance",
+                    "type": "bool"
+                },
+                {
+                    "name": "v",
+                    "type": "uint8[]"
+                },
+                {
+                    "name": "r",
+                    "type": "bytes32[]"
+                },
+                {
+                    "name": "s",
+                    "type": "bytes32[]"
+                }
+            ],
+            "name": "fillOrdersUpTo",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "orderAddresses",
+                    "type": "address[5]"
+                },
+                {
+                    "name": "orderValues",
+                    "type": "uint256[6]"
+                },
+                {
+                    "name": "cancelTakerTokenAmount",
+                    "type": "uint256"
+                }
+            ],
+            "name": "cancelOrder",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "ZRX_TOKEN_CONTRACT",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "orderAddresses",
+                    "type": "address[5][]"
+                },
+                {
+                    "name": "orderValues",
+                    "type": "uint256[6][]"
+                },
+                {
+                    "name": "fillTakerTokenAmounts",
+                    "type": "uint256[]"
+                },
+                {
+                    "name": "v",
+                    "type": "uint8[]"
+                },
+                {
+                    "name": "r",
+                    "type": "bytes32[]"
+                },
+                {
+                    "name": "s",
+                    "type": "bytes32[]"
+                }
+            ],
+            "name": "batchFillOrKillOrders",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "orderAddresses",
+                    "type": "address[5]"
+                },
+                {
+                    "name": "orderValues",
+                    "type": "uint256[6]"
+                },
+                {
+                    "name": "fillTakerTokenAmount",
+                    "type": "uint256"
+                },
+                {
+                    "name": "v",
+                    "type": "uint8"
+                },
+                {
+                    "name": "r",
+                    "type": "bytes32"
+                },
+                {
+                    "name": "s",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "fillOrKillOrder",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "orderHash",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "getUnavailableTakerTokenAmount",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "signer",
+                    "type": "address"
+                },
+                {
+                    "name": "hash",
+                    "type": "bytes32"
+                },
+                {
+                    "name": "v",
+                    "type": "uint8"
+                },
+                {
+                    "name": "r",
+                    "type": "bytes32"
+                },
+                {
+                    "name": "s",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "isValidSignature",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "numerator",
+                    "type": "uint256"
+                },
+                {
+                    "name": "denominator",
+                    "type": "uint256"
+                },
+                {
+                    "name": "target",
+                    "type": "uint256"
+                }
+            ],
+            "name": "getPartialAmount",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "TOKEN_TRANSFER_PROXY_CONTRACT",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "orderAddresses",
+                    "type": "address[5][]"
+                },
+                {
+                    "name": "orderValues",
+                    "type": "uint256[6][]"
+                },
+                {
+                    "name": "fillTakerTokenAmounts",
+                    "type": "uint256[]"
+                },
+                {
+                    "name": "shouldThrowOnInsufficientBalanceOrAllowance",
+                    "type": "bool"
+                },
+                {
+                    "name": "v",
+                    "type": "uint8[]"
+                },
+                {
+                    "name": "r",
+                    "type": "bytes32[]"
+                },
+                {
+                    "name": "s",
+                    "type": "bytes32[]"
+                }
+            ],
+            "name": "batchFillOrders",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "orderAddresses",
+                    "type": "address[5][]"
+                },
+                {
+                    "name": "orderValues",
+                    "type": "uint256[6][]"
+                },
+                {
+                    "name": "cancelTakerTokenAmounts",
+                    "type": "uint256[]"
+                }
+            ],
+            "name": "batchCancelOrders",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "orderAddresses",
+                    "type": "address[5]"
+                },
+                {
+                    "name": "orderValues",
+                    "type": "uint256[6]"
+                },
+                {
+                    "name": "fillTakerTokenAmount",
+                    "type": "uint256"
+                },
+                {
+                    "name": "shouldThrowOnInsufficientBalanceOrAllowance",
+                    "type": "bool"
+                },
+                {
+                    "name": "v",
+                    "type": "uint8"
+                },
+                {
+                    "name": "r",
+                    "type": "bytes32"
+                },
+                {
+                    "name": "s",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "fillOrder",
+            "outputs": [
+                {
+                    "name": "filledTakerTokenAmount",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "orderAddresses",
+                    "type": "address[5]"
+                },
+                {
+                    "name": "orderValues",
+                    "type": "uint256[6]"
+                }
+            ],
+            "name": "getOrderHash",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "bytes32"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "EXTERNAL_QUERY_GAS_LIMIT",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "uint16"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "VERSION",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "string"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "inputs": [
+                {
+                    "name": "_zrxToken",
+                    "type": "address"
+                },
+                {
+                    "name": "_tokenTransferProxy",
+                    "type": "address"
+                }
+            ],
+            "payable": false,
+            "type": "constructor"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "maker",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "taker",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "name": "feeRecipient",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "makerToken",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "takerToken",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "filledMakerTokenAmount",
+                    "type": "uint256"
+                },
+                {
+                    "indexed": false,
+                    "name": "filledTakerTokenAmount",
+                    "type": "uint256"
+                },
+                {
+                    "indexed": false,
+                    "name": "paidMakerFee",
+                    "type": "uint256"
+                },
+                {
+                    "indexed": false,
+                    "name": "paidTakerFee",
+                    "type": "uint256"
+                },
+                {
+                    "indexed": true,
+                    "name": "tokens",
+                    "type": "bytes32"
+                },
+                {
+                    "indexed": false,
+                    "name": "orderHash",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "LogFill",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "maker",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "name": "feeRecipient",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "makerToken",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "takerToken",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "cancelledMakerTokenAmount",
+                    "type": "uint256"
+                },
+                {
+                    "indexed": false,
+                    "name": "cancelledTakerTokenAmount",
+                    "type": "uint256"
+                },
+                {
+                    "indexed": true,
+                    "name": "tokens",
+                    "type": "bytes32"
+                },
+                {
+                    "indexed": false,
+                    "name": "orderHash",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "LogCancel",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "errorId",
+                    "type": "uint8"
+                },
+                {
+                    "indexed": true,
+                    "name": "orderHash",
+                    "type": "bytes32"
+                }
+            ],
+            "name": "LogError",
+            "type": "event"
+        }
+    ],
+    "networks": {
+        "1": {
+            "address": "0x12459c951127e0c374ff9105dda097662a027093"
+        },
+        "3": {
+            "address": "0x479cc461fecd078f766ecc58533d6f69580cf3ac"
+        },
+        "4": {
+            "address": "0x1d16ef40fac01cec8adac2ac49427b9384192c05"
+        },
+        "42": {
+            "address": "0x90fe2af704b34e0224bf2299c838e04d4dcf1364"
+        },
+        "50": {
+            "address": "0x48bacb9266a570d521063ef5dd96e61686dbe788"
+        }
+    }
+}

packages/contract-wrappers/src/compact_artifacts/Token.json

@@ -0,0 +1,172 @@
+{
+    "contract_name": "Token",
+    "abi": [
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_spender",
+                    "type": "address"
+                },
+                {
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "approve",
+            "outputs": [
+                {
+                    "name": "success",
+                    "type": "bool"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "totalSupply",
+            "outputs": [
+                {
+                    "name": "supply",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_from",
+                    "type": "address"
+                },
+                {
+                    "name": "_to",
+                    "type": "address"
+                },
+                {
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "transferFrom",
+            "outputs": [
+                {
+                    "name": "success",
+                    "type": "bool"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "_owner",
+                    "type": "address"
+                }
+            ],
+            "name": "balanceOf",
+            "outputs": [
+                {
+                    "name": "balance",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_to",
+                    "type": "address"
+                },
+                {
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "transfer",
+            "outputs": [
+                {
+                    "name": "success",
+                    "type": "bool"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "_owner",
+                    "type": "address"
+                },
+                {
+                    "name": "_spender",
+                    "type": "address"
+                }
+            ],
+            "name": "allowance",
+            "outputs": [
+                {
+                    "name": "remaining",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "_from",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "name": "_to",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "Transfer",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "_owner",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "name": "_spender",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "_value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "Approval",
+            "type": "event"
+        }
+    ]
+}

packages/contract-wrappers/src/compact_artifacts/TokenRegistry.json

@@ -0,0 +1,547 @@
+{
+    "contract_name": "TokenRegistry",
+    "abi": [
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_token",
+                    "type": "address"
+                },
+                {
+                    "name": "_index",
+                    "type": "uint256"
+                }
+            ],
+            "name": "removeToken",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "_name",
+                    "type": "string"
+                }
+            ],
+            "name": "getTokenAddressByName",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "_symbol",
+                    "type": "string"
+                }
+            ],
+            "name": "getTokenAddressBySymbol",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_token",
+                    "type": "address"
+                },
+                {
+                    "name": "_swarmHash",
+                    "type": "bytes"
+                }
+            ],
+            "name": "setTokenSwarmHash",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "_token",
+                    "type": "address"
+                }
+            ],
+            "name": "getTokenMetaData",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "name": "",
+                    "type": "string"
+                },
+                {
+                    "name": "",
+                    "type": "string"
+                },
+                {
+                    "name": "",
+                    "type": "uint8"
+                },
+                {
+                    "name": "",
+                    "type": "bytes"
+                },
+                {
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "owner",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_token",
+                    "type": "address"
+                },
+                {
+                    "name": "_name",
+                    "type": "string"
+                },
+                {
+                    "name": "_symbol",
+                    "type": "string"
+                },
+                {
+                    "name": "_decimals",
+                    "type": "uint8"
+                },
+                {
+                    "name": "_ipfsHash",
+                    "type": "bytes"
+                },
+                {
+                    "name": "_swarmHash",
+                    "type": "bytes"
+                }
+            ],
+            "name": "addToken",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_token",
+                    "type": "address"
+                },
+                {
+                    "name": "_name",
+                    "type": "string"
+                }
+            ],
+            "name": "setTokenName",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "tokens",
+            "outputs": [
+                {
+                    "name": "token",
+                    "type": "address"
+                },
+                {
+                    "name": "name",
+                    "type": "string"
+                },
+                {
+                    "name": "symbol",
+                    "type": "string"
+                },
+                {
+                    "name": "decimals",
+                    "type": "uint8"
+                },
+                {
+                    "name": "ipfsHash",
+                    "type": "bytes"
+                },
+                {
+                    "name": "swarmHash",
+                    "type": "bytes"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "tokenAddresses",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "_name",
+                    "type": "string"
+                }
+            ],
+            "name": "getTokenByName",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "name": "",
+                    "type": "string"
+                },
+                {
+                    "name": "",
+                    "type": "string"
+                },
+                {
+                    "name": "",
+                    "type": "uint8"
+                },
+                {
+                    "name": "",
+                    "type": "bytes"
+                },
+                {
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "getTokenAddresses",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address[]"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_token",
+                    "type": "address"
+                },
+                {
+                    "name": "_ipfsHash",
+                    "type": "bytes"
+                }
+            ],
+            "name": "setTokenIpfsHash",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "_symbol",
+                    "type": "string"
+                }
+            ],
+            "name": "getTokenBySymbol",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                },
+                {
+                    "name": "",
+                    "type": "string"
+                },
+                {
+                    "name": "",
+                    "type": "string"
+                },
+                {
+                    "name": "",
+                    "type": "uint8"
+                },
+                {
+                    "name": "",
+                    "type": "bytes"
+                },
+                {
+                    "name": "",
+                    "type": "bytes"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "_token",
+                    "type": "address"
+                },
+                {
+                    "name": "_symbol",
+                    "type": "string"
+                }
+            ],
+            "name": "setTokenSymbol",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "newOwner",
+                    "type": "address"
+                }
+            ],
+            "name": "transferOwnership",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "token",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "name",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "name": "symbol",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "name": "decimals",
+                    "type": "uint8"
+                },
+                {
+                    "indexed": false,
+                    "name": "ipfsHash",
+                    "type": "bytes"
+                },
+                {
+                    "indexed": false,
+                    "name": "swarmHash",
+                    "type": "bytes"
+                }
+            ],
+            "name": "LogAddToken",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "token",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "name",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "name": "symbol",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "name": "decimals",
+                    "type": "uint8"
+                },
+                {
+                    "indexed": false,
+                    "name": "ipfsHash",
+                    "type": "bytes"
+                },
+                {
+                    "indexed": false,
+                    "name": "swarmHash",
+                    "type": "bytes"
+                }
+            ],
+            "name": "LogRemoveToken",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "token",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "oldName",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "name": "newName",
+                    "type": "string"
+                }
+            ],
+            "name": "LogTokenNameChange",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "token",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "oldSymbol",
+                    "type": "string"
+                },
+                {
+                    "indexed": false,
+                    "name": "newSymbol",
+                    "type": "string"
+                }
+            ],
+            "name": "LogTokenSymbolChange",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "token",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "oldIpfsHash",
+                    "type": "bytes"
+                },
+                {
+                    "indexed": false,
+                    "name": "newIpfsHash",
+                    "type": "bytes"
+                }
+            ],
+            "name": "LogTokenIpfsHashChange",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "token",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "name": "oldSwarmHash",
+                    "type": "bytes"
+                },
+                {
+                    "indexed": false,
+                    "name": "newSwarmHash",
+                    "type": "bytes"
+                }
+            ],
+            "name": "LogTokenSwarmHashChange",
+            "type": "event"
+        }
+    ],
+    "networks": {
+        "1": {
+            "address": "0x926a74c5c36adf004c87399e65f75628b0f98d2c"
+        },
+        "3": {
+            "address": "0x6b1a50f0bb5a7995444bd3877b22dc89c62843ed"
+        },
+        "4": {
+            "address": "0x4e9aad8184de8833365fea970cd9149372fdf1e6"
+        },
+        "42": {
+            "address": "0xf18e504561f4347bea557f3d4558f559dddbae7f"
+        },
+        "50": {
+            "address": "0x0b1ba0af832d7c05fd64161e0db78e85978e8082"
+        }
+    }
+}

packages/contract-wrappers/src/compact_artifacts/TokenTransferProxy.json

@@ -0,0 +1,187 @@
+{
+    "contract_name": "TokenTransferProxy",
+    "abi": [
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "token",
+                    "type": "address"
+                },
+                {
+                    "name": "from",
+                    "type": "address"
+                },
+                {
+                    "name": "to",
+                    "type": "address"
+                },
+                {
+                    "name": "value",
+                    "type": "uint256"
+                }
+            ],
+            "name": "transferFrom",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "target",
+                    "type": "address"
+                }
+            ],
+            "name": "addAuthorizedAddress",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "name": "authorities",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "target",
+                    "type": "address"
+                }
+            ],
+            "name": "removeAuthorizedAddress",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "owner",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "name": "authorized",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "getAuthorizedAddresses",
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "address[]"
+                }
+            ],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "name": "newOwner",
+                    "type": "address"
+                }
+            ],
+            "name": "transferOwnership",
+            "outputs": [],
+            "payable": false,
+            "type": "function"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "target",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "name": "caller",
+                    "type": "address"
+                }
+            ],
+            "name": "LogAuthorizedAddressAdded",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": true,
+                    "name": "target",
+                    "type": "address"
+                },
+                {
+                    "indexed": true,
+                    "name": "caller",
+                    "type": "address"
+                }
+            ],
+            "name": "LogAuthorizedAddressRemoved",
+            "type": "event"
+        }
+    ],
+    "networks": {
+        "1": {
+            "address": "0x8da0d80f5007ef1e431dd2127178d224e32c2ef4"
+        },
+        "3": {
+            "address": "0x4e9aad8184de8833365fea970cd9149372fdf1e6"
+        },
+        "4": {
+            "address": "0xa8e9fa8f91e5ae138c74648c9c304f1c75003a8d"
+        },
+        "42": {
+            "address": "0x087eed4bc1ee3de49befbd66c662b434b15d49d4"
+        },
+        "50": {
+            "address": "0x1dc4c1cefef38a777b15aa20260a54e584b16c48"
+        }
+    }
+}

packages/contract-wrappers/src/compact_artifacts/ZRX.json

@@ -0,0 +1,20 @@
+{
+    "contract_name": "ZRX",
+    "networks": {
+        "1": {
+            "address": "0xe41d2489571d322189246dafa5ebde1f4699f498"
+        },
+        "3": {
+            "address": "0xa8e9fa8f91e5ae138c74648c9c304f1c75003a8d"
+        },
+        "4": {
+            "address": "0x00f58d6d585f84b2d7267940cede30ce2fe6eae8"
+        },
+        "42": {
+            "address": "0x6ff6c0ff1d68b964901f986d4c9fa3ac68346570"
+        },
+        "50": {
+            "address": "0x1d7022f5b17d2f8b695918fb48fa1089c9f85401"
+        }
+    }
+}

packages/contract-wrappers/src/contract_wrappers.ts

@@ -0,0 +1,112 @@
+import { Provider } from '@0xproject/types';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as _ from 'lodash';
+
+import { artifacts } from './artifacts';
+import { EtherTokenWrapper } from './contract_wrappers/ether_token_wrapper';
+import { ExchangeWrapper } from './contract_wrappers/exchange_wrapper';
+import { TokenRegistryWrapper } from './contract_wrappers/token_registry_wrapper';
+import { TokenTransferProxyWrapper } from './contract_wrappers/token_transfer_proxy_wrapper';
+import { TokenWrapper } from './contract_wrappers/token_wrapper';
+import { ContractWrappersConfigSchema } from './schemas/contract_wrappers_config_schema';
+import { contractWrappersPrivateNetworkConfigSchema } from './schemas/contract_wrappers_private_network_config_schema';
+import { contractWrappersPublicNetworkConfigSchema } from './schemas/contract_wrappers_public_network_config_schema';
+import { ContractWrappersConfig } from './types';
+import { assert } from './utils/assert';
+/**
+ * The ContractWrappers class contains smart contract wrappers helpful when building on 0x protocol.
+ */
+export class ContractWrappers {
+    /**
+     * An instance of the ExchangeWrapper class containing methods for interacting with the 0x Exchange smart contract.
+     */
+    public exchange: ExchangeWrapper;
+    /**
+     * An instance of the TokenRegistryWrapper class containing methods for interacting with the 0x
+     * TokenRegistry smart contract.
+     */
+    public tokenRegistry: TokenRegistryWrapper;
+    /**
+     * An instance of the TokenWrapper class containing methods for interacting with any ERC20 token smart contract.
+     */
+    public token: TokenWrapper;
+    /**
+     * An instance of the EtherTokenWrapper class containing methods for interacting with the
+     * wrapped ETH ERC20 token smart contract.
+     */
+    public etherToken: EtherTokenWrapper;
+    /**
+     * An instance of the TokenTransferProxyWrapper class containing methods for interacting with the
+     * tokenTransferProxy smart contract.
+     */
+    public proxy: TokenTransferProxyWrapper;
+    private _web3Wrapper: Web3Wrapper;
+    /**
+     * Instantiates a new ContractWrappers instance.
+     * @param   provider    The Provider instance you would like the 0x.js library to use for interacting with
+     *                      the Ethereum network.
+     * @param   config      The configuration object. Look up the type for the description.
+     * @return  An instance of the ContractWrappers class.
+     */
+    constructor(provider: Provider, config: ContractWrappersConfig) {
+        assert.isWeb3Provider('provider', provider);
+        assert.doesConformToSchema('config', config, ContractWrappersConfigSchema, [
+            contractWrappersPrivateNetworkConfigSchema,
+            contractWrappersPublicNetworkConfigSchema,
+        ]);
+        const artifactJSONs = _.values(artifacts);
+        const abiArrays = _.map(artifactJSONs, artifact => artifact.abi);
+        const txDefaults = {
+            gasPrice: config.gasPrice,
+        };
+        this._web3Wrapper = new Web3Wrapper(provider, txDefaults);
+        _.forEach(abiArrays, abi => {
+            this._web3Wrapper.abiDecoder.addABI(abi);
+        });
+        this.proxy = new TokenTransferProxyWrapper(
+            this._web3Wrapper,
+            config.networkId,
+            config.tokenTransferProxyContractAddress,
+        );
+        this.token = new TokenWrapper(this._web3Wrapper, config.networkId, this.proxy);
+        this.exchange = new ExchangeWrapper(
+            this._web3Wrapper,
+            config.networkId,
+            this.token,
+            config.exchangeContractAddress,
+            config.zrxContractAddress,
+        );
+        this.tokenRegistry = new TokenRegistryWrapper(
+            this._web3Wrapper,
+            config.networkId,
+            config.tokenRegistryContractAddress,
+        );
+        this.etherToken = new EtherTokenWrapper(this._web3Wrapper, config.networkId, this.token);
+    }
+    /**
+     * Sets a new web3 provider for 0x.js. Updating the provider will stop all
+     * subscriptions so you will need to re-subscribe to all events relevant to your app after this call.
+     * @param   provider    The Web3Provider you would like the 0x.js library to use from now on.
+     * @param   networkId   The id of the network your provider is connected to
+     */
+    public setProvider(provider: Provider, networkId: number): void {
+        this._web3Wrapper.setProvider(provider);
+        (this.exchange as any)._invalidateContractInstances();
+        (this.exchange as any)._setNetworkId(networkId);
+        (this.tokenRegistry as any)._invalidateContractInstance();
+        (this.tokenRegistry as any)._setNetworkId(networkId);
+        (this.token as any)._invalidateContractInstances();
+        (this.token as any)._setNetworkId(networkId);
+        (this.proxy as any)._invalidateContractInstance();
+        (this.proxy as any)._setNetworkId(networkId);
+        (this.etherToken as any)._invalidateContractInstance();
+        (this.etherToken as any)._setNetworkId(networkId);
+    }
+    /**
+     * Get the provider instance currently used by 0x.js
+     * @return  Web3 provider instance
+     */
+    public getProvider(): Provider {
+        return this._web3Wrapper.getProvider();
+    }
+}

packages/contract-wrappers/src/contract_wrappers/contract_wrapper.ts

@@ -1,32 +1,38 @@
-import { BlockParamLiteral, ContractAbi, FilterObject, LogEntry, LogWithDecodedArgs, RawLog } from '@0xproject/types';
+import {
+    Artifact,
+    BlockParamLiteral,
+    ContractAbi,
+    FilterObject,
+    LogEntry,
+    LogWithDecodedArgs,
+    RawLog,
+} from '@0xproject/types';
 import { AbiDecoder, intervalUtils } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import { Block, BlockAndLogStreamer } from 'ethereumjs-blockstream';
 import * as _ from 'lodash';
-import * as Web3 from 'web3';
 
 import {
-    Artifact,
     BlockRange,
     ContractEventArgs,
     ContractEvents,
+    ContractWrappersError,
     EventCallback,
     IndexedFilterValues,
-    InternalZeroExError,
-    ZeroExError,
+    InternalContractWrappersError,
 } from '../types';
 import { constants } from '../utils/constants';
 import { filterUtils } from '../utils/filter_utils';
 
 const CONTRACT_NAME_TO_NOT_FOUND_ERROR: {
-    [contractName: string]: ZeroExError;
+    [contractName: string]: ContractWrappersError;
 } = {
-    ZRX: ZeroExError.ZRXContractDoesNotExist,
-    EtherToken: ZeroExError.EtherTokenContractDoesNotExist,
-    Token: ZeroExError.TokenContractDoesNotExist,
-    TokenRegistry: ZeroExError.TokenRegistryContractDoesNotExist,
-    TokenTransferProxy: ZeroExError.TokenTransferProxyContractDoesNotExist,
-    Exchange: ZeroExError.ExchangeContractDoesNotExist,
+    ZRX: ContractWrappersError.ZRXContractDoesNotExist,
+    EtherToken: ContractWrappersError.EtherTokenContractDoesNotExist,
+    Token: ContractWrappersError.TokenContractDoesNotExist,
+    TokenRegistry: ContractWrappersError.TokenRegistryContractDoesNotExist,
+    TokenTransferProxy: ContractWrappersError.TokenTransferProxyContractDoesNotExist,
+    Exchange: ContractWrappersError.ExchangeContractDoesNotExist,
 };
 
 export class ContractWrapper {
@@ -57,7 +63,7 @@ export class ContractWrapper {
     }
     protected _unsubscribe(filterToken: string, err?: Error): void {
         if (_.isUndefined(this._filters[filterToken])) {
-            throw new Error(ZeroExError.SubscriptionNotFound);
+            throw new Error(ContractWrappersError.SubscriptionNotFound);
         }
         if (!_.isUndefined(err)) {
             const callback = this._filterCallbacks[filterToken];
@@ -101,7 +107,7 @@ export class ContractWrapper {
         log: LogEntry,
     ): LogWithDecodedArgs<ArgsType> | RawLog {
         if (_.isUndefined(this._web3Wrapper.abiDecoder)) {
-            throw new Error(InternalZeroExError.NoAbiDecoder);
+            throw new Error(InternalContractWrappersError.NoAbiDecoder);
         }
         const logWithDecodedArgs = this._web3Wrapper.abiDecoder.tryToDecodeLogOrNoop(log);
         return logWithDecodedArgs;
@@ -113,7 +119,7 @@ export class ContractWrapper {
         let contractAddress: string;
         if (_.isUndefined(addressIfExists)) {
             if (_.isUndefined(artifact.networks[this._networkId])) {
-                throw new Error(ZeroExError.ContractNotDeployedOnNetwork);
+                throw new Error(ContractWrappersError.ContractNotDeployedOnNetwork);
             }
             contractAddress = artifact.networks[this._networkId].address.toLowerCase();
         } else {
@@ -130,7 +136,7 @@ export class ContractWrapper {
         if (_.isUndefined(addressIfExists)) {
             const contractAddress = artifact.networks[this._networkId].address;
             if (_.isUndefined(contractAddress)) {
-                throw new Error(ZeroExError.ExchangeContractDoesNotExist);
+                throw new Error(ContractWrappersError.ExchangeContractDoesNotExist);
             }
             return contractAddress;
         } else {
@@ -151,7 +157,7 @@ export class ContractWrapper {
     }
     private _startBlockAndLogStream(): void {
         if (!_.isUndefined(this._blockAndLogStreamerIfExists)) {
-            throw new Error(ZeroExError.SubscriptionAlreadyPresent);
+            throw new Error(ContractWrappersError.SubscriptionAlreadyPresent);
         }
         this._blockAndLogStreamerIfExists = new BlockAndLogStreamer(
             this._web3Wrapper.getBlockAsync.bind(this._web3Wrapper),
@@ -184,7 +190,7 @@ export class ContractWrapper {
     }
     private _stopBlockAndLogStream(): void {
         if (_.isUndefined(this._blockAndLogStreamerIfExists)) {
-            throw new Error(ZeroExError.SubscriptionNotFound);
+            throw new Error(ContractWrappersError.SubscriptionNotFound);
         }
         this._blockAndLogStreamerIfExists.unsubscribeFromOnLogAdded(this._onLogAddedSubscriptionToken as string);
         this._blockAndLogStreamerIfExists.unsubscribeFromOnLogRemoved(this._onLogRemovedSubscriptionToken as string);

packages/contract-wrappers/src/contract_wrappers/ether_token_wrapper.ts

@@ -5,7 +5,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
 
 import { artifacts } from '../artifacts';
-import { BlockRange, EventCallback, IndexedFilterValues, TransactionOpts, ZeroExError } from '../types';
+import { BlockRange, ContractWrappersError, EventCallback, IndexedFilterValues, TransactionOpts } from '../types';
 import { assert } from '../utils/assert';
 
 import { ContractWrapper } from './contract_wrapper';
@@ -48,7 +48,7 @@ export class EtherTokenWrapper extends ContractWrapper {
         const normalizedDepositorAddress = depositor.toLowerCase();
 
         const ethBalanceInWei = await this._web3Wrapper.getBalanceInWeiAsync(normalizedDepositorAddress);
-        assert.assert(ethBalanceInWei.gte(amountInWei), ZeroExError.InsufficientEthBalanceForDeposit);
+        assert.assert(ethBalanceInWei.gte(amountInWei), ContractWrappersError.InsufficientEthBalanceForDeposit);
 
         const wethContract = await this._getEtherTokenContractAsync(normalizedEtherTokenAddress);
         const txHash = await wethContract.deposit.sendTransactionAsync({
@@ -84,7 +84,10 @@ export class EtherTokenWrapper extends ContractWrapper {
             normalizedEtherTokenAddress,
             normalizedWithdrawerAddress,
         );
-        assert.assert(WETHBalanceInBaseUnits.gte(amountInWei), ZeroExError.InsufficientWEthBalanceForWithdrawal);
+        assert.assert(
+            WETHBalanceInBaseUnits.gte(amountInWei),
+            ContractWrappersError.InsufficientWEthBalanceForWithdrawal,
+        );
 
         const wethContract = await this._getEtherTokenContractAsync(normalizedEtherTokenAddress);
         const txHash = await wethContract.withdraw.sendTransactionAsync(amountInWei, {
@@ -119,7 +122,7 @@ export class EtherTokenWrapper extends ContractWrapper {
             eventName,
             blockRange,
             indexFilterValues,
-            artifacts.EtherTokenArtifact.abi,
+            artifacts.EtherToken.abi,
         );
         return logs;
     }
@@ -147,7 +150,7 @@ export class EtherTokenWrapper extends ContractWrapper {
             normalizedEtherTokenAddress,
             eventName,
             indexFilterValues,
-            artifacts.EtherTokenArtifact.abi,
+            artifacts.EtherToken.abi,
             callback,
         );
         return subscriptionToken;
@@ -172,7 +175,7 @@ export class EtherTokenWrapper extends ContractWrapper {
      * @returns The Ethereum address of the EtherToken contract or undefined.
      */
     public getContractAddressIfExists(): string | undefined {
-        const networkSpecificArtifact = artifacts.EtherTokenArtifact.networks[this._networkId];
+        const networkSpecificArtifact = artifacts.EtherToken.networks[this._networkId];
         const contractAddressIfExists = _.isUndefined(networkSpecificArtifact)
             ? undefined
             : networkSpecificArtifact.address;
@@ -188,7 +191,7 @@ export class EtherTokenWrapper extends ContractWrapper {
             return etherTokenContract;
         }
         const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
-            artifacts.EtherTokenArtifact,
+            artifacts.EtherToken,
             etherTokenAddress,
         );
         const contractInstance = new EtherTokenContract(

packages/contract-wrappers/src/contract_wrappers/exchange_wrapper.ts

@@ -1,11 +1,16 @@
 import { schemas } from '@0xproject/json-schemas';
+import { formatters, getOrderHashHex, OrderStateUtils } from '@0xproject/order-utils';
 import {
     BlockParamLiteral,
     DecodedLogArgs,
     ECSignature,
+    ExchangeContractErrs,
     LogEntry,
     LogWithDecodedArgs,
     Order,
+    OrderAddresses,
+    OrderState,
+    OrderValues,
     SignedOrder,
 } from '@0xproject/types';
 import { AbiDecoder, BigNumber } from '@0xproject/utils';
@@ -19,21 +24,16 @@ import {
     BlockRange,
     EventCallback,
     ExchangeContractErrCodes,
-    ExchangeContractErrs,
     IndexedFilterValues,
     MethodOpts,
-    OrderAddresses,
     OrderCancellationRequest,
     OrderFillRequest,
-    OrderState,
     OrderTransactionOpts,
-    OrderValues,
     ValidateOrderFillableOpts,
 } from '../types';
 import { assert } from '../utils/assert';
 import { decorators } from '../utils/decorators';
 import { ExchangeTransferSimulator } from '../utils/exchange_transfer_simulator';
-import { OrderStateUtils } from '../utils/order_state_utils';
 import { OrderValidationUtils } from '../utils/order_validation_utils';
 import { utils } from '../utils/utils';
 
@@ -69,24 +69,6 @@ export class ExchangeWrapper extends ContractWrapper {
     };
     private _contractAddressIfExists?: string;
     private _zrxContractAddressIfExists?: string;
-    private static _getOrderAddressesAndValues(order: Order): [OrderAddresses, OrderValues] {
-        const orderAddresses: OrderAddresses = [
-            order.maker,
-            order.taker,
-            order.makerTokenAddress,
-            order.takerTokenAddress,
-            order.feeRecipient,
-        ];
-        const orderValues: OrderValues = [
-            order.makerTokenAmount,
-            order.takerTokenAmount,
-            order.makerFee,
-            order.takerFee,
-            order.expirationUnixTimestampSec,
-            order.salt,
-        ];
-        return [orderAddresses, orderValues];
-    }
     constructor(
         web3Wrapper: Web3Wrapper,
         networkId: number,
@@ -208,7 +190,7 @@ export class ExchangeWrapper extends ContractWrapper {
             );
         }
 
-        const [orderAddresses, orderValues] = ExchangeWrapper._getOrderAddressesAndValues(signedOrder);
+        const [orderAddresses, orderValues] = formatters.getOrderAddressesAndValues(signedOrder);
 
         const txHash: string = await exchangeInstance.fillOrder.sendTransactionAsync(
             orderAddresses,
@@ -295,7 +277,7 @@ export class ExchangeWrapper extends ContractWrapper {
 
         const orderAddressesValuesAndSignatureArray = _.map(signedOrders, signedOrder => {
             return [
-                ...ExchangeWrapper._getOrderAddressesAndValues(signedOrder),
+                ...formatters.getOrderAddressesAndValues(signedOrder),
                 signedOrder.ecSignature.v,
                 signedOrder.ecSignature.r,
                 signedOrder.ecSignature.s,
@@ -383,7 +365,7 @@ export class ExchangeWrapper extends ContractWrapper {
 
         const orderAddressesValuesAmountsAndSignatureArray = _.map(orderFillRequests, orderFillRequest => {
             return [
-                ...ExchangeWrapper._getOrderAddressesAndValues(orderFillRequest.signedOrder),
+                ...formatters.getOrderAddressesAndValues(orderFillRequest.signedOrder),
                 orderFillRequest.takerTokenFillAmount,
                 orderFillRequest.signedOrder.ecSignature.v,
                 orderFillRequest.signedOrder.ecSignature.r,
@@ -452,7 +434,7 @@ export class ExchangeWrapper extends ContractWrapper {
             );
         }
 
-        const [orderAddresses, orderValues] = ExchangeWrapper._getOrderAddressesAndValues(signedOrder);
+        const [orderAddresses, orderValues] = formatters.getOrderAddressesAndValues(signedOrder);
         const txHash = await exchangeInstance.fillOrKillOrder.sendTransactionAsync(
             orderAddresses,
             orderValues,
@@ -518,7 +500,7 @@ export class ExchangeWrapper extends ContractWrapper {
 
         const orderAddressesValuesAndTakerTokenFillAmounts = _.map(orderFillRequests, request => {
             return [
-                ...ExchangeWrapper._getOrderAddressesAndValues(request.signedOrder),
+                ...formatters.getOrderAddressesAndValues(request.signedOrder),
                 request.takerTokenFillAmount,
                 request.signedOrder.ecSignature.v,
                 request.signedOrder.ecSignature.r,
@@ -570,7 +552,7 @@ export class ExchangeWrapper extends ContractWrapper {
             ? SHOULD_VALIDATE_BY_DEFAULT
             : orderTransactionOpts.shouldValidate;
         if (shouldValidate) {
-            const orderHash = utils.getOrderHashHex(order);
+            const orderHash = getOrderHashHex(order);
             const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
             OrderValidationUtils.validateCancelOrderThrowIfInvalid(
                 order,
@@ -579,7 +561,7 @@ export class ExchangeWrapper extends ContractWrapper {
             );
         }
 
-        const [orderAddresses, orderValues] = ExchangeWrapper._getOrderAddressesAndValues(order);
+        const [orderAddresses, orderValues] = formatters.getOrderAddressesAndValues(order);
         const txHash = await exchangeInstance.cancelOrder.sendTransactionAsync(
             orderAddresses,
             orderValues,
@@ -629,7 +611,7 @@ export class ExchangeWrapper extends ContractWrapper {
             : orderTransactionOpts.shouldValidate;
         if (shouldValidate) {
             for (const orderCancellationRequest of orderCancellationRequests) {
-                const orderHash = utils.getOrderHashHex(orderCancellationRequest.order);
+                const orderHash = getOrderHashHex(orderCancellationRequest.order);
                 const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
                 OrderValidationUtils.validateCancelOrderThrowIfInvalid(
                     orderCancellationRequest.order,
@@ -644,7 +626,7 @@ export class ExchangeWrapper extends ContractWrapper {
         const exchangeInstance = await this._getExchangeContractAsync();
         const orderAddressesValuesAndTakerTokenCancelAmounts = _.map(orderCancellationRequests, cancellationRequest => {
             return [
-                ...ExchangeWrapper._getOrderAddressesAndValues(cancellationRequest.order),
+                ...formatters.getOrderAddressesAndValues(cancellationRequest.order),
                 cancellationRequest.takerTokenCancelAmount,
             ];
         });
@@ -685,7 +667,7 @@ export class ExchangeWrapper extends ContractWrapper {
             exchangeContractAddress,
             eventName,
             indexFilterValues,
-            artifacts.ExchangeArtifact.abi,
+            artifacts.Exchange.abi,
             callback,
         );
         return subscriptionToken;
@@ -725,7 +707,7 @@ export class ExchangeWrapper extends ContractWrapper {
             eventName,
             blockRange,
             indexFilterValues,
-            artifacts.ExchangeArtifact.abi,
+            artifacts.Exchange.abi,
         );
         return logs;
     }
@@ -735,7 +717,7 @@ export class ExchangeWrapper extends ContractWrapper {
      * @returns The Ethereum address of the Exchange contract being used.
      */
     public getContractAddress(): string {
-        const contractAddress = this._getContractAddress(artifacts.ExchangeArtifact, this._contractAddressIfExists);
+        const contractAddress = this._getContractAddress(artifacts.Exchange, this._contractAddressIfExists);
         return contractAddress;
     }
     /**
@@ -801,7 +783,7 @@ export class ExchangeWrapper extends ContractWrapper {
     ): Promise<void> {
         assert.doesConformToSchema('order', order, schemas.orderSchema);
         assert.isValidBaseUnitAmount('cancelTakerTokenAmount', cancelTakerTokenAmount);
-        const orderHash = utils.getOrderHashHex(order);
+        const orderHash = getOrderHashHex(order);
         const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
         OrderValidationUtils.validateCancelOrderThrowIfInvalid(
             order,
@@ -903,7 +885,7 @@ export class ExchangeWrapper extends ContractWrapper {
      * @return Address of ZRX token
      */
     public getZRXTokenAddress(): string {
-        const contractAddress = this._getContractAddress(artifacts.ZRXArtifact, this._zrxContractAddressIfExists);
+        const contractAddress = this._getContractAddress(artifacts.ZRX, this._zrxContractAddressIfExists);
         return contractAddress;
     }
     private _invalidateContractInstances(): void {
@@ -933,7 +915,7 @@ export class ExchangeWrapper extends ContractWrapper {
     }
     private async _getOrderHashHexUsingContractCallAsync(order: Order | SignedOrder): Promise<string> {
         const exchangeInstance = await this._getExchangeContractAsync();
-        const [orderAddresses, orderValues] = ExchangeWrapper._getOrderAddressesAndValues(order);
+        const [orderAddresses, orderValues] = formatters.getOrderAddressesAndValues(order);
         const orderHashHex = await exchangeInstance.getOrderHash.callAsync(orderAddresses, orderValues);
         return orderHashHex;
     }
@@ -942,7 +924,7 @@ export class ExchangeWrapper extends ContractWrapper {
             return this._exchangeContractIfExists;
         }
         const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
-            artifacts.ExchangeArtifact,
+            artifacts.Exchange,
             this._contractAddressIfExists,
         );
         const contractInstance = new ExchangeContract(
@@ -954,10 +936,4 @@ export class ExchangeWrapper extends ContractWrapper {
         this._exchangeContractIfExists = contractInstance;
         return this._exchangeContractIfExists;
     }
-    private async _getTokenTransferProxyAddressAsync(): Promise<string> {
-        const exchangeInstance = await this._getExchangeContractAsync();
-        const tokenTransferProxyAddress = await exchangeInstance.TOKEN_TRANSFER_PROXY_CONTRACT.callAsync();
-        const tokenTransferProxyAddressLowerCase = tokenTransferProxyAddress.toLowerCase();
-        return tokenTransferProxyAddressLowerCase;
-    }
 } // tslint:disable:max-file-line-count

packages/contract-wrappers/src/contract_wrappers/token_registry_wrapper.ts

@@ -1,8 +1,9 @@
+import { Token } from '@0xproject/types';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
 
 import { artifacts } from '../artifacts';
-import { Token, TokenMetadata } from '../types';
+import { TokenMetadata } from '../types';
 import { assert } from '../utils/assert';
 import { constants } from '../utils/constants';
 
@@ -104,10 +105,7 @@ export class TokenRegistryWrapper extends ContractWrapper {
      * @returns The Ethereum address of the TokenRegistry contract being used.
      */
     public getContractAddress(): string {
-        const contractAddress = this._getContractAddress(
-            artifacts.TokenRegistryArtifact,
-            this._contractAddressIfExists,
-        );
+        const contractAddress = this._getContractAddress(artifacts.TokenRegistry, this._contractAddressIfExists);
         return contractAddress;
     }
     private _invalidateContractInstance(): void {
@@ -118,7 +116,7 @@ export class TokenRegistryWrapper extends ContractWrapper {
             return this._tokenRegistryContractIfExists;
         }
         const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
-            artifacts.TokenRegistryArtifact,
+            artifacts.TokenRegistry,
             this._contractAddressIfExists,
         );
         const contractInstance = new TokenRegistryContract(

packages/contract-wrappers/src/contract_wrappers/token_transfer_proxy_wrapper.ts

@@ -46,10 +46,7 @@ export class TokenTransferProxyWrapper extends ContractWrapper {
      * @returns The Ethereum address of the TokenTransferProxy contract being used.
      */
     public getContractAddress(): string {
-        const contractAddress = this._getContractAddress(
-            artifacts.TokenTransferProxyArtifact,
-            this._contractAddressIfExists,
-        );
+        const contractAddress = this._getContractAddress(artifacts.TokenTransferProxy, this._contractAddressIfExists);
         return contractAddress;
     }
     private _invalidateContractInstance(): void {
@@ -60,7 +57,7 @@ export class TokenTransferProxyWrapper extends ContractWrapper {
             return this._tokenTransferProxyContractIfExists;
         }
         const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
-            artifacts.TokenTransferProxyArtifact,
+            artifacts.TokenTransferProxy,
             this._contractAddressIfExists,
         );
         const contractInstance = new TokenTransferProxyContract(

packages/contract-wrappers/src/contract_wrappers/token_wrapper.ts

@@ -5,7 +5,14 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
 
 import { artifacts } from '../artifacts';
-import { BlockRange, EventCallback, IndexedFilterValues, MethodOpts, TransactionOpts, ZeroExError } from '../types';
+import {
+    BlockRange,
+    ContractWrappersError,
+    EventCallback,
+    IndexedFilterValues,
+    MethodOpts,
+    TransactionOpts,
+} from '../types';
 import { assert } from '../utils/assert';
 import { constants } from '../utils/constants';
 
@@ -266,7 +273,7 @@ export class TokenWrapper extends ContractWrapper {
 
         const fromAddressBalance = await this.getBalanceAsync(normalizedTokenAddress, normalizedFromAddress);
         if (fromAddressBalance.lessThan(amountInBaseUnits)) {
-            throw new Error(ZeroExError.InsufficientBalanceForTransfer);
+            throw new Error(ContractWrappersError.InsufficientBalanceForTransfer);
         }
 
         const txHash = await tokenContract.transfer.sendTransactionAsync(normalizedToAddress, amountInBaseUnits, {
@@ -316,12 +323,12 @@ export class TokenWrapper extends ContractWrapper {
             normalizedSenderAddress,
         );
         if (fromAddressAllowance.lessThan(amountInBaseUnits)) {
-            throw new Error(ZeroExError.InsufficientAllowanceForTransfer);
+            throw new Error(ContractWrappersError.InsufficientAllowanceForTransfer);
         }
 
         const fromAddressBalance = await this.getBalanceAsync(normalizedTokenAddress, normalizedFromAddress);
         if (fromAddressBalance.lessThan(amountInBaseUnits)) {
-            throw new Error(ZeroExError.InsufficientBalanceForTransfer);
+            throw new Error(ContractWrappersError.InsufficientBalanceForTransfer);
         }
 
         const txHash = await tokenContract.transferFrom.sendTransactionAsync(
@@ -360,7 +367,7 @@ export class TokenWrapper extends ContractWrapper {
             normalizedTokenAddress,
             eventName,
             indexFilterValues,
-            artifacts.TokenArtifact.abi,
+            artifacts.Token.abi,
             callback,
         );
         return subscriptionToken;
@@ -403,7 +410,7 @@ export class TokenWrapper extends ContractWrapper {
             eventName,
             blockRange,
             indexFilterValues,
-            artifacts.TokenArtifact.abi,
+            artifacts.Token.abi,
         );
         return logs;
     }
@@ -418,7 +425,7 @@ export class TokenWrapper extends ContractWrapper {
             return tokenContract;
         }
         const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
-            artifacts.TokenArtifact,
+            artifacts.Token,
             normalizedTokenAddress,
         );
         const contractInstance = new TokenContract(

packages/contract-wrappers/src/fetchers/simple_balance_and_proxy_allowance_fetcher.ts

@@ -1,10 +1,10 @@
+import { AbstractBalanceAndProxyAllowanceFetcher } from '@0xproject/order-utils';
 import { BlockParamLiteral } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 
-import { BalanceAndProxyAllowanceFetcher } from '../abstract/balance_and_proxy_allowance_fetcher';
 import { TokenWrapper } from '../contract_wrappers/token_wrapper';
 
-export class SimpleBalanceAndProxyAllowanceFetcher implements BalanceAndProxyAllowanceFetcher {
+export class SimpleBalanceAndProxyAllowanceFetcher implements AbstractBalanceAndProxyAllowanceFetcher {
     private _tokenWrapper: TokenWrapper;
     private _defaultBlock: BlockParamLiteral;
     constructor(token: TokenWrapper, defaultBlock: BlockParamLiteral) {

packages/contract-wrappers/src/fetchers/simple_order_filled_cancelled_fetcher.ts

@@ -1,10 +1,10 @@
+import { AbstractOrderFilledCancelledFetcher } from '@0xproject/order-utils';
 import { BlockParamLiteral } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 
-import { OrderFilledCancelledFetcher } from '../abstract/order_filled_cancelled_fetcher';
 import { ExchangeWrapper } from '../contract_wrappers/exchange_wrapper';
 
-export class SimpleOrderFilledCancelledFetcher implements OrderFilledCancelledFetcher {
+export class SimpleOrderFilledCancelledFetcher implements AbstractOrderFilledCancelledFetcher {
     private _exchangeWrapper: ExchangeWrapper;
     private _defaultBlock: BlockParamLiteral;
     constructor(exchange: ExchangeWrapper, defaultBlock: BlockParamLiteral) {
@@ -25,4 +25,12 @@ export class SimpleOrderFilledCancelledFetcher implements OrderFilledCancelledFe
         const cancelledTakerAmount = this._exchangeWrapper.getCancelledTakerAmountAsync(orderHash, methodOpts);
         return cancelledTakerAmount;
     }
+    public async getUnavailableTakerAmountAsync(orderHash: string): Promise<BigNumber> {
+        const unavailableTakerAmount = await this._exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
+        return unavailableTakerAmount;
+    }
+    public getZRXTokenAddress(): string {
+        const zrxToken = this._exchangeWrapper.getZRXTokenAddress();
+        return zrxToken;
+    }
 }

packages/contract-wrappers/src/index.ts

@@ -0,0 +1,68 @@
+export { ContractWrappers } from './contract_wrappers';
+export { ExchangeWrapper } from './contract_wrappers/exchange_wrapper';
+export { TokenWrapper } from './contract_wrappers/token_wrapper';
+export { TokenRegistryWrapper } from './contract_wrappers/token_registry_wrapper';
+export { EtherTokenWrapper } from './contract_wrappers/ether_token_wrapper';
+export { TokenTransferProxyWrapper } from './contract_wrappers/token_transfer_proxy_wrapper';
+
+export {
+    ContractWrappersError,
+    EventCallback,
+    ContractEvent,
+    Token,
+    IndexedFilterValues,
+    BlockRange,
+    OrderCancellationRequest,
+    OrderFillRequest,
+    ContractEventArgs,
+    ContractWrappersConfig,
+    MethodOpts,
+    OrderTransactionOpts,
+    TransactionOpts,
+    LogEvent,
+    DecodedLogEvent,
+    OnOrderStateChangeCallback,
+} from './types';
+
+export {
+    BlockParamLiteral,
+    FilterObject,
+    BlockParam,
+    ContractEventArg,
+    ExchangeContractErrs,
+    LogWithDecodedArgs,
+    Order,
+    Provider,
+    SignedOrder,
+    ECSignature,
+    OrderStateValid,
+    OrderStateInvalid,
+    OrderState,
+    TransactionReceipt,
+    TransactionReceiptWithDecodedLogs,
+} from '@0xproject/types';
+
+export {
+    EtherTokenContractEventArgs,
+    WithdrawalContractEventArgs,
+    DepositContractEventArgs,
+    EtherTokenEvents,
+} from './contract_wrappers/generated/ether_token';
+
+export {
+    TransferContractEventArgs,
+    ApprovalContractEventArgs,
+    TokenContractEventArgs,
+    TokenEvents,
+} from './contract_wrappers/generated/token';
+
+export {
+    LogErrorContractEventArgs,
+    LogCancelContractEventArgs,
+    LogFillContractEventArgs,
+    ExchangeContractEventArgs,
+    ExchangeEvents,
+} from './contract_wrappers/generated/exchange';
+
+export { BalanceAndProxyAllowanceLazyStore } from './stores/balance_proxy_allowance_lazy_store';
+export { OrderFilledCancelledLazyStore } from './stores/order_filled_cancelled_lazy_store';

packages/contract-wrappers/src/schemas/contract_wrappers_config_schema.ts

@@ -0,0 +1,5 @@
+export const ContractWrappersConfigSchema = {
+    id: '/ContractWrappersConfig',
+    oneOf: [{ $ref: '/ZeroExContractPrivateNetworkConfig' }, { $ref: '/ZeroExContractPublicNetworkConfig' }],
+    type: 'object',
+};

packages/contract-wrappers/src/schemas/contract_wrappers_private_network_config_schema.ts

@@ -0,0 +1,35 @@
+export const contractWrappersPrivateNetworkConfigSchema = {
+    id: '/ZeroExContractPrivateNetworkConfig',
+    properties: {
+        networkId: {
+            type: 'number',
+            minimum: 1,
+        },
+        gasPrice: { $ref: '/Number' },
+        zrxContractAddress: { $ref: '/Address' },
+        exchangeContractAddress: { $ref: '/Address' },
+        tokenRegistryContractAddress: { $ref: '/Address' },
+        tokenTransferProxyContractAddress: { $ref: '/Address' },
+        orderWatcherConfig: {
+            type: 'object',
+            properties: {
+                pollingIntervalMs: {
+                    type: 'number',
+                    minimum: 0,
+                },
+                numConfirmations: {
+                    type: 'number',
+                    minimum: 0,
+                },
+            },
+        },
+    },
+    type: 'object',
+    required: [
+        'networkId',
+        'zrxContractAddress',
+        'exchangeContractAddress',
+        'tokenRegistryContractAddress',
+        'tokenTransferProxyContractAddress',
+    ],
+};

packages/contract-wrappers/src/schemas/contract_wrappers_public_network_config_schema.ts

@@ -0,0 +1,43 @@
+const networkNameToId: { [networkName: string]: number } = {
+    mainnet: 1,
+    ropsten: 3,
+    rinkeby: 4,
+    kovan: 42,
+    ganache: 50,
+};
+
+export const contractWrappersPublicNetworkConfigSchema = {
+    id: '/ZeroExContractPublicNetworkConfig',
+    properties: {
+        networkId: {
+            type: 'number',
+            enum: [
+                networkNameToId.mainnet,
+                networkNameToId.kovan,
+                networkNameToId.ropsten,
+                networkNameToId.rinkeby,
+                networkNameToId.ganache,
+            ],
+        },
+        gasPrice: { $ref: '/Number' },
+        zrxContractAddress: { $ref: '/Address' },
+        exchangeContractAddress: { $ref: '/Address' },
+        tokenRegistryContractAddress: { $ref: '/Address' },
+        tokenTransferProxyContractAddress: { $ref: '/Address' },
+        orderWatcherConfig: {
+            type: 'object',
+            properties: {
+                pollingIntervalMs: {
+                    type: 'number',
+                    minimum: 0,
+                },
+                numConfirmations: {
+                    type: 'number',
+                    minimum: 0,
+                },
+            },
+        },
+    },
+    type: 'object',
+    required: ['networkId'],
+};

packages/contract-wrappers/src/stores/balance_proxy_allowance_lazy_store.ts

@@ -1,14 +1,14 @@
+import { AbstractBalanceAndProxyAllowanceFetcher } from '@0xproject/order-utils';
 import { BlockParamLiteral } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 
-import { BalanceAndProxyAllowanceFetcher } from '../abstract/balance_and_proxy_allowance_fetcher';
 import { TokenWrapper } from '../contract_wrappers/token_wrapper';
 
 /**
  * Copy on read store for balances/proxyAllowances of tokens/accounts
  */
-export class BalanceAndProxyAllowanceLazyStore implements BalanceAndProxyAllowanceFetcher {
+export class BalanceAndProxyAllowanceLazyStore implements AbstractBalanceAndProxyAllowanceFetcher {
     private _tokenWrapper: TokenWrapper;
     private _defaultBlock: BlockParamLiteral;
     private _balance: {

packages/contract-wrappers/src/stores/order_filled_cancelled_lazy_store.ts

@@ -1,14 +1,14 @@
+import { AbstractOrderFilledCancelledFetcher } from '@0xproject/order-utils';
 import { BlockParamLiteral } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 
-import { OrderFilledCancelledFetcher } from '../abstract/order_filled_cancelled_fetcher';
 import { ExchangeWrapper } from '../contract_wrappers/exchange_wrapper';
 
 /**
  * Copy on read store for filled/cancelled taker amounts
  */
-export class OrderFilledCancelledLazyStore implements OrderFilledCancelledFetcher {
+export class OrderFilledCancelledLazyStore implements AbstractOrderFilledCancelledFetcher {
     private _exchangeWrapper: ExchangeWrapper;
     private _defaultBlock: BlockParamLiteral;
     private _filledTakerAmount: {
@@ -64,4 +64,12 @@ export class OrderFilledCancelledLazyStore implements OrderFilledCancelledFetche
         this._filledTakerAmount = {};
         this._cancelledTakerAmount = {};
     }
+    public async getUnavailableTakerAmountAsync(orderHash: string): Promise<BigNumber> {
+        const unavailableTakerAmount = await this._exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
+        return unavailableTakerAmount;
+    }
+    public getZRXTokenAddress(): string {
+        const zrxToken = this._exchangeWrapper.getZRXTokenAddress();
+        return zrxToken;
+    }
 }

packages/contract-wrappers/src/types.ts

@@ -0,0 +1,186 @@
+import { BigNumber } from '@0xproject/utils';
+
+import {
+    BlockParam,
+    BlockParamLiteral,
+    ContractAbi,
+    ContractEventArg,
+    ExchangeContractErrs,
+    FilterObject,
+    LogEntryEvent,
+    LogWithDecodedArgs,
+    Order,
+    OrderState,
+    SignedOrder,
+} from '@0xproject/types';
+
+import { EtherTokenContractEventArgs, EtherTokenEvents } from './contract_wrappers/generated/ether_token';
+import { ExchangeContractEventArgs, ExchangeEvents } from './contract_wrappers/generated/exchange';
+import { TokenContractEventArgs, TokenEvents } from './contract_wrappers/generated/token';
+
+export enum ContractWrappersError {
+    ExchangeContractDoesNotExist = 'EXCHANGE_CONTRACT_DOES_NOT_EXIST',
+    ZRXContractDoesNotExist = 'ZRX_CONTRACT_DOES_NOT_EXIST',
+    EtherTokenContractDoesNotExist = 'ETHER_TOKEN_CONTRACT_DOES_NOT_EXIST',
+    TokenTransferProxyContractDoesNotExist = 'TOKEN_TRANSFER_PROXY_CONTRACT_DOES_NOT_EXIST',
+    TokenRegistryContractDoesNotExist = 'TOKEN_REGISTRY_CONTRACT_DOES_NOT_EXIST',
+    TokenContractDoesNotExist = 'TOKEN_CONTRACT_DOES_NOT_EXIST',
+    ContractNotDeployedOnNetwork = 'CONTRACT_NOT_DEPLOYED_ON_NETWORK',
+    InsufficientAllowanceForTransfer = 'INSUFFICIENT_ALLOWANCE_FOR_TRANSFER',
+    InsufficientBalanceForTransfer = 'INSUFFICIENT_BALANCE_FOR_TRANSFER',
+    InsufficientEthBalanceForDeposit = 'INSUFFICIENT_ETH_BALANCE_FOR_DEPOSIT',
+    InsufficientWEthBalanceForWithdrawal = 'INSUFFICIENT_WETH_BALANCE_FOR_WITHDRAWAL',
+    InvalidJump = 'INVALID_JUMP',
+    OutOfGas = 'OUT_OF_GAS',
+    SubscriptionNotFound = 'SUBSCRIPTION_NOT_FOUND',
+    SubscriptionAlreadyPresent = 'SUBSCRIPTION_ALREADY_PRESENT',
+}
+
+export enum InternalContractWrappersError {
+    NoAbiDecoder = 'NO_ABI_DECODER',
+    ZrxNotInTokenRegistry = 'ZRX_NOT_IN_TOKEN_REGISTRY',
+    WethNotInTokenRegistry = 'WETH_NOT_IN_TOKEN_REGISTRY',
+}
+
+export type LogEvent = LogEntryEvent;
+export interface DecodedLogEvent<ArgsType> {
+    isRemoved: boolean;
+    log: LogWithDecodedArgs<ArgsType>;
+}
+
+export type EventCallback<ArgsType> = (err: null | Error, log?: DecodedLogEvent<ArgsType>) => void;
+
+export enum ExchangeContractErrCodes {
+    ERROR_FILL_EXPIRED, // Order has already expired
+    ERROR_FILL_NO_VALUE, // Order has already been fully filled or cancelled
+    ERROR_FILL_TRUNCATION, // Rounding error too large
+    ERROR_FILL_BALANCE_ALLOWANCE, // Insufficient balance or allowance for token transfer
+    ERROR_CANCEL_EXPIRED, // Order has already expired
+    ERROR_CANCEL_NO_VALUE, // Order has already been fully filled or cancelled
+}
+
+export interface ContractEvent {
+    logIndex: number;
+    transactionIndex: number;
+    transactionHash: string;
+    blockHash: string;
+    blockNumber: number;
+    address: string;
+    type: string;
+    event: string;
+    args: ContractEventArgs;
+}
+
+export type ContractEventArgs = ExchangeContractEventArgs | TokenContractEventArgs | EtherTokenContractEventArgs;
+
+//                          [address, name, symbol, decimals, ipfsHash, swarmHash]
+export type TokenMetadata = [string, string, string, number, string, string];
+
+export interface Token {
+    name: string;
+    address: string;
+    symbol: string;
+    decimals: number;
+}
+
+export interface TxOpts {
+    from: string;
+    gas?: number;
+    value?: BigNumber;
+    gasPrice?: BigNumber;
+}
+
+export interface TokenAddressBySymbol {
+    [symbol: string]: string;
+}
+
+export type ContractEvents = TokenEvents | ExchangeEvents | EtherTokenEvents;
+
+export interface IndexedFilterValues {
+    [index: string]: ContractEventArg;
+}
+
+export interface BlockRange {
+    fromBlock: BlockParam;
+    toBlock: BlockParam;
+}
+
+export interface OrderCancellationRequest {
+    order: Order | SignedOrder;
+    takerTokenCancelAmount: BigNumber;
+}
+
+export interface OrderFillRequest {
+    signedOrder: SignedOrder;
+    takerTokenFillAmount: BigNumber;
+}
+
+export type AsyncMethod = (...args: any[]) => Promise<any>;
+export type SyncMethod = (...args: any[]) => any;
+
+/**
+ * networkId: The id of the underlying ethereum network your provider is connected to. (1-mainnet, 3-ropsten, 4-rinkeby, 42-kovan, 50-testrpc)
+ * gasPrice: Gas price to use with every transaction
+ * exchangeContractAddress: The address of an exchange contract to use
+ * zrxContractAddress: The address of the ZRX contract to use
+ * tokenRegistryContractAddress: The address of a token registry contract to use
+ * tokenTransferProxyContractAddress: The address of the token transfer proxy contract to use
+ * orderWatcherConfig: All the configs related to the orderWatcher
+ */
+export interface ContractWrappersConfig {
+    networkId: number;
+    gasPrice?: BigNumber;
+    exchangeContractAddress?: string;
+    zrxContractAddress?: string;
+    tokenRegistryContractAddress?: string;
+    tokenTransferProxyContractAddress?: string;
+}
+
+/**
+ * expectedFillTakerTokenAmount: If specified, the validation method will ensure that the
+ * supplied order maker has a sufficient allowance/balance to fill this amount of the order's
+ * takerTokenAmount. If not specified, the validation method ensures that the maker has a sufficient
+ * allowance/balance to fill the entire remaining order amount.
+ */
+export interface ValidateOrderFillableOpts {
+    expectedFillTakerTokenAmount?: BigNumber;
+}
+
+/**
+ * defaultBlock: The block up to which to query the blockchain state. Setting this to a historical block number
+ * let's the user query the blockchain's state at an arbitrary point in time. In order for this to work, the
+ * backing  Ethereum node must keep the entire historical state of the chain (e.g setting `--pruning=archive`
+ * flag when  running Parity).
+ */
+export interface MethodOpts {
+    defaultBlock?: BlockParam;
+}
+
+/**
+ * gasPrice: Gas price in Wei to use for a transaction
+ * gasLimit: The amount of gas to send with a transaction
+ */
+export interface TransactionOpts {
+    gasPrice?: BigNumber;
+    gasLimit?: number;
+}
+
+/**
+ * shouldValidate: Flag indicating whether the library should make attempts to validate a transaction before
+ * broadcasting it. For example, order has a valid signature, maker has sufficient funds, etc. Default=true.
+ */
+export interface OrderTransactionOpts extends TransactionOpts {
+    shouldValidate?: boolean;
+}
+
+export enum TradeSide {
+    Maker = 'maker',
+    Taker = 'taker',
+}
+
+export enum TransferType {
+    Trade = 'trade',
+    Fee = 'fee',
+}
+
+export type OnOrderStateChangeCallback = (err: Error | null, orderState?: OrderState) => void;

packages/contract-wrappers/src/utils/assert.ts

@@ -8,13 +8,13 @@ import { BigNumber } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
 
-import { signatureUtils } from '../utils/signature_utils';
+import { isValidSignature } from '@0xproject/order-utils';
 
 export const assert = {
     ...sharedAssert,
-    isValidSignature(orderHash: string, ecSignature: ECSignature, signerAddress: string) {
-        const isValidSignature = signatureUtils.isValidSignature(orderHash, ecSignature, signerAddress);
-        this.assert(isValidSignature, `Expected order with hash '${orderHash}' to have a valid signature`);
+    isValidSignature(orderHash: string, ecSignature: ECSignature, signerAddress: string): void {
+        const isValid = isValidSignature(orderHash, ecSignature, signerAddress);
+        this.assert(isValid, `Expected order with hash '${orderHash}' to have a valid signature`);
     },
     async isSenderAddressAsync(
         variableName: string,
@@ -28,8 +28,4 @@ export const assert = {
             `Specified ${variableName} ${senderAddressHex} isn't available through the supplied web3 provider`,
         );
     },
-    async isUserAddressAvailableAsync(web3Wrapper: Web3Wrapper): Promise<void> {
-        const availableAddresses = await web3Wrapper.getAvailableAddressesAsync();
-        this.assert(!_.isEmpty(availableAddresses), 'No addresses were available on the provided web3 provider');
-    },
 };

packages/contract-wrappers/src/utils/constants.ts

@@ -0,0 +1,12 @@
+import { BigNumber } from '@0xproject/utils';
+
+export const constants = {
+    NULL_ADDRESS: '0x0000000000000000000000000000000000000000',
+    TESTRPC_NETWORK_ID: 50,
+    INVALID_JUMP_PATTERN: 'invalid JUMP at',
+    OUT_OF_GAS_PATTERN: 'out of gas',
+    INVALID_TAKER_FORMAT: 'instance.taker is not of a type(s) string',
+    // tslint:disable-next-line:custom-no-magic-numbers
+    UNLIMITED_ALLOWANCE_IN_BASE_UNITS: new BigNumber(2).pow(256).minus(1),
+    DEFAULT_BLOCK_POLLING_INTERVAL: 1000,
+};

packages/contract-wrappers/src/utils/decorators.ts

@@ -1,6 +1,6 @@
 import * as _ from 'lodash';
 
-import { AsyncMethod, SyncMethod, ZeroExError } from '../types';
+import { AsyncMethod, ContractWrappersError, SyncMethod } from '../types';
 
 import { constants } from './constants';
 
@@ -8,10 +8,10 @@ type ErrorTransformer = (err: Error) => Error;
 
 const contractCallErrorTransformer = (error: Error) => {
     if (_.includes(error.message, constants.INVALID_JUMP_PATTERN)) {
-        return new Error(ZeroExError.InvalidJump);
+        return new Error(ContractWrappersError.InvalidJump);
     }
     if (_.includes(error.message, constants.OUT_OF_GAS_PATTERN)) {
-        return new Error(ZeroExError.OutOfGas);
+        return new Error(ContractWrappersError.OutOfGas);
     }
     return error;
 };
@@ -39,7 +39,7 @@ const asyncErrorHandlerFactory = (errorTransformer: ErrorTransformer) => {
         // Do not use arrow syntax here. Use a function expression in
         // order to use the correct value of `this` in this method
         // tslint:disable-next-line:only-arrow-functions
-        descriptor.value = async function(...args: any[]) {
+        descriptor.value = async function(...args: any[]): Promise<any> {
             try {
                 const result = await originalMethod.apply(this, args);
                 return result;
@@ -66,7 +66,7 @@ const syncErrorHandlerFactory = (errorTransformer: ErrorTransformer) => {
         // Do not use arrow syntax here. Use a function expression in
         // order to use the correct value of `this` in this method
         // tslint:disable-next-line:only-arrow-functions
-        descriptor.value = function(...args: any[]) {
+        descriptor.value = function(...args: any[]): any {
             try {
                 const result = originalMethod.apply(this, args);
                 return result;

packages/contract-wrappers/src/utils/exchange_transfer_simulator.ts

@@ -1,10 +1,11 @@
-import { BlockParamLiteral } from '@0xproject/types';
+import { BlockParamLiteral, ExchangeContractErrs } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 
 import { TokenWrapper } from '../contract_wrappers/token_wrapper';
 import { BalanceAndProxyAllowanceLazyStore } from '../stores/balance_proxy_allowance_lazy_store';
-import { ExchangeContractErrs, TradeSide, TransferType } from '../types';
+import { TradeSide, TransferType } from '../types';
+import { constants } from '../utils/constants';
 
 enum FailureReason {
     Balance = 'balance',
@@ -66,6 +67,13 @@ export class ExchangeTransferSimulator {
         tradeSide: TradeSide,
         transferType: TransferType,
     ): Promise<void> {
+        // HACK: When simulating an open order (e.g taker is NULL_ADDRESS), we don't want to adjust balances/
+        // allowances for the taker. We do however, want to increase the balance of the maker since the maker
+        // might be relying on those funds to fill subsequent orders or pay the order's fees.
+        if (from === constants.NULL_ADDRESS && tradeSide === TradeSide.Taker) {
+            await this._increaseBalanceAsync(tokenAddress, to, amountInBaseUnits);
+            return;
+        }
         const balance = await this._store.getBalanceAsync(tokenAddress, from);
         const proxyAllowance = await this._store.getProxyAllowanceAsync(tokenAddress, from);
         if (proxyAllowance.lessThan(amountInBaseUnits)) {

packages/contract-wrappers/src/utils/filter_utils.ts

@@ -73,14 +73,14 @@ export const filterUtils = {
             return false;
         }
         if (!_.isUndefined(filter.topics)) {
-            return filterUtils.matchesTopics(log.topics, filter.topics);
+            return filterUtils.doesMatchTopics(log.topics, filter.topics);
         }
         return true;
     },
-    matchesTopics(logTopics: string[], filterTopics: Array<string[] | string | null>): boolean {
+    doesMatchTopics(logTopics: string[], filterTopics: Array<string[] | string | null>): boolean {
         const matchesTopic = _.zipWith(logTopics, filterTopics, filterUtils.matchesTopic.bind(filterUtils));
-        const matchesTopics = _.every(matchesTopic);
-        return matchesTopics;
+        const doesMatchTopics = _.every(matchesTopic);
+        return doesMatchTopics;
     },
     matchesTopic(logTopic: string, filterTopic: string[] | string | null): boolean {
         if (_.isArray(filterTopic)) {

packages/contract-wrappers/src/utils/order_validation_utils.ts

@@ -1,10 +1,10 @@
-import { Order, SignedOrder } from '@0xproject/types';
+import { getOrderHashHex, isValidSignature, OrderError } from '@0xproject/order-utils';
+import { ExchangeContractErrs, Order, SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 
-import { ZeroEx } from '../0x';
 import { ExchangeWrapper } from '../contract_wrappers/exchange_wrapper';
-import { ExchangeContractErrs, TradeSide, TransferType, ZeroExError } from '../types';
+import { ContractWrappersError, TradeSide, TransferType } from '../types';
 import { constants } from '../utils/constants';
 import { utils } from '../utils/utils';
 
@@ -86,12 +86,12 @@ export class OrderValidationUtils {
     private static _validateRemainingFillAmountNotZeroOrThrow(
         takerTokenAmount: BigNumber,
         unavailableTakerTokenAmount: BigNumber,
-    ) {
+    ): void {
         if (takerTokenAmount.eq(unavailableTakerTokenAmount)) {
             throw new Error(ExchangeContractErrs.OrderRemainingFillAmountZero);
         }
     }
-    private static _validateOrderNotExpiredOrThrow(expirationUnixTimestampSec: BigNumber) {
+    private static _validateOrderNotExpiredOrThrow(expirationUnixTimestampSec: BigNumber): void {
         const currentUnixTimestampSec = utils.getCurrentUnixTimestampSec();
         if (expirationUnixTimestampSec.lessThan(currentUnixTimestampSec)) {
             throw new Error(ExchangeContractErrs.OrderFillExpired);
@@ -113,7 +113,7 @@ export class OrderValidationUtils {
         zrxTokenAddress: string,
         expectedFillTakerTokenAmount?: BigNumber,
     ): Promise<void> {
-        const orderHash = utils.getOrderHashHex(signedOrder);
+        const orderHash = getOrderHashHex(signedOrder);
         const unavailableTakerTokenAmount = await this._exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
         OrderValidationUtils._validateRemainingFillAmountNotZeroOrThrow(
             signedOrder.takerTokenAmount,
@@ -124,31 +124,12 @@ export class OrderValidationUtils {
         if (!_.isUndefined(expectedFillTakerTokenAmount)) {
             fillTakerTokenAmount = expectedFillTakerTokenAmount;
         }
-        const fillMakerTokenAmount = OrderValidationUtils._getPartialAmount(
+        await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+            exchangeTradeEmulator,
+            signedOrder,
             fillTakerTokenAmount,
-            signedOrder.takerTokenAmount,
-            signedOrder.makerTokenAmount,
-        );
-        await exchangeTradeEmulator.transferFromAsync(
-            signedOrder.makerTokenAddress,
-            signedOrder.maker,
             signedOrder.taker,
-            fillMakerTokenAmount,
-            TradeSide.Maker,
-            TransferType.Trade,
-        );
-        const makerFeeAmount = OrderValidationUtils._getPartialAmount(
-            fillTakerTokenAmount,
-            signedOrder.takerTokenAmount,
-            signedOrder.makerFee,
-        );
-        await exchangeTradeEmulator.transferFromAsync(
             zrxTokenAddress,
-            signedOrder.maker,
-            signedOrder.feeRecipient,
-            makerFeeAmount,
-            TradeSide.Maker,
-            TransferType.Fee,
         );
     }
     public async validateFillOrderThrowIfInvalidAsync(
@@ -161,9 +142,9 @@ export class OrderValidationUtils {
         if (fillTakerTokenAmount.eq(0)) {
             throw new Error(ExchangeContractErrs.OrderFillAmountZero);
         }
-        const orderHash = utils.getOrderHashHex(signedOrder);
-        if (!ZeroEx.isValidSignature(orderHash, signedOrder.ecSignature, signedOrder.maker)) {
-            throw new Error(ZeroExError.InvalidSignature);
+        const orderHash = getOrderHashHex(signedOrder);
+        if (!isValidSignature(orderHash, signedOrder.ecSignature, signedOrder.maker)) {
+            throw new Error(OrderError.InvalidSignature);
         }
         const unavailableTakerTokenAmount = await this._exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
         OrderValidationUtils._validateRemainingFillAmountNotZeroOrThrow(

packages/contract-wrappers/src/utils/utils.ts

@@ -0,0 +1,14 @@
+import { BigNumber } from '@0xproject/utils';
+
+export const utils = {
+    spawnSwitchErr(name: string, value: any): Error {
+        return new Error(`Unexpected switch value: ${value} encountered for ${name}`);
+    },
+    getCurrentUnixTimestampSec(): BigNumber {
+        const milisecondsInSecond = 1000;
+        return new BigNumber(Date.now() / milisecondsInSecond).round();
+    },
+    getCurrentUnixTimestampMs(): BigNumber {
+        return new BigNumber(Date.now());
+    },
+};

packages/contract-wrappers/test/artifacts_test.ts

@@ -0,0 +1,50 @@
+import { web3Factory } from '@0xproject/dev-utils';
+import * as fs from 'fs';
+import 'make-promises-safe';
+
+import { ContractWrappers } from '../src';
+
+import { chaiSetup } from './utils/chai_setup';
+import { constants } from './utils/constants';
+
+chaiSetup.configure();
+
+// Those tests are slower cause they're talking to a remote node
+const TIMEOUT = 10000;
+
+describe('Artifacts', () => {
+    describe('contracts are deployed on kovan', () => {
+        const kovanRpcUrl = constants.KOVAN_RPC_URL;
+        const provider = web3Factory.create({ rpcUrl: kovanRpcUrl }).currentProvider;
+        const config = {
+            networkId: constants.KOVAN_NETWORK_ID,
+        };
+        const contractWrappers = new ContractWrappers(provider, config);
+        it('token registry contract is deployed', async () => {
+            await (contractWrappers.tokenRegistry as any)._getTokenRegistryContractAsync();
+        }).timeout(TIMEOUT);
+        it('proxy contract is deployed', async () => {
+            await (contractWrappers.proxy as any)._getTokenTransferProxyContractAsync();
+        }).timeout(TIMEOUT);
+        it('exchange contract is deployed', async () => {
+            await (contractWrappers.exchange as any)._getExchangeContractAsync();
+        }).timeout(TIMEOUT);
+    });
+    describe('contracts are deployed on ropsten', () => {
+        const ropstenRpcUrl = constants.ROPSTEN_RPC_URL;
+        const provider = web3Factory.create({ rpcUrl: ropstenRpcUrl }).currentProvider;
+        const config = {
+            networkId: constants.ROPSTEN_NETWORK_ID,
+        };
+        const contractWrappers = new ContractWrappers(provider, config);
+        it('token registry contract is deployed', async () => {
+            await (contractWrappers.tokenRegistry as any)._getTokenRegistryContractAsync();
+        }).timeout(TIMEOUT);
+        it('proxy contract is deployed', async () => {
+            await (contractWrappers.proxy as any)._getTokenTransferProxyContractAsync();
+        }).timeout(TIMEOUT);
+        it('exchange contract is deployed', async () => {
+            await (contractWrappers.exchange as any)._getExchangeContractAsync();
+        }).timeout(TIMEOUT);
+    });
+});

packages/contract-wrappers/test/ether_token_wrapper_test.ts

@@ -1,27 +1,27 @@
-import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
+import { BlockchainLifecycle, callbackErrorReporter, devConstants, web3Factory } from '@0xproject/dev-utils';
+import { DoneCallback } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as chai from 'chai';
+import 'make-promises-safe';
 import 'mocha';
 
 import {
     ApprovalContractEventArgs,
     BlockParamLiteral,
     BlockRange,
+    ContractWrappers,
+    ContractWrappersError,
     DecodedLogEvent,
     DepositContractEventArgs,
     EtherTokenEvents,
     Token,
     TransferContractEventArgs,
     WithdrawalContractEventArgs,
-    ZeroEx,
-    ZeroExError,
 } from '../src';
-import { DoneCallback } from '../src/types';
 
 import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
-import { reportNodeCallbackErrors } from './utils/report_callback_errors';
 import { TokenUtils } from './utils/token_utils';
 import { provider, web3Wrapper } from './utils/web3_wrapper';
 
@@ -36,13 +36,13 @@ const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 const MAX_REASONABLE_GAS_COST_IN_WEI = 62517;
 
 describe('EtherTokenWrapper', () => {
-    let zeroEx: ZeroEx;
+    let contractWrappers: ContractWrappers;
     let tokens: Token[];
     let userAddresses: string[];
     let addressWithETH: string;
     let wethContractAddress: string;
     let depositWeiAmount: BigNumber;
-    let decimalPlaces: number;
+    const decimalPlaces = 7;
     let addressWithoutFunds: string;
     const gasPrice = new BigNumber(1);
     const zeroExConfig = {
@@ -54,13 +54,12 @@ describe('EtherTokenWrapper', () => {
     const depositAmount = new BigNumber(42);
     const withdrawalAmount = new BigNumber(42);
     before(async () => {
-        zeroEx = new ZeroEx(provider, zeroExConfig);
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
-        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        contractWrappers = new ContractWrappers(provider, zeroExConfig);
+        tokens = await contractWrappers.tokenRegistry.getTokensAsync();
+        userAddresses = await web3Wrapper.getAvailableAddressesAsync();
         addressWithETH = userAddresses[0];
-        wethContractAddress = zeroEx.etherToken.getContractAddressIfExists() as string;
+        wethContractAddress = contractWrappers.etherToken.getContractAddressIfExists() as string;
         depositWeiAmount = Web3Wrapper.toWei(new BigNumber(5));
-        decimalPlaces = 7;
         addressWithoutFunds = userAddresses[1];
     });
     beforeEach(async () => {
@@ -71,14 +70,14 @@ describe('EtherTokenWrapper', () => {
     });
     describe('#getContractAddressIfExists', async () => {
         it('should return contract address if connected to a known network', () => {
-            const contractAddressIfExists = zeroEx.etherToken.getContractAddressIfExists();
+            const contractAddressIfExists = contractWrappers.etherToken.getContractAddressIfExists();
             expect(contractAddressIfExists).to.not.be.undefined();
         });
         it('should throw if connected to a private network and contract addresses are not specified', () => {
             const UNKNOWN_NETWORK_NETWORK_ID = 10;
             expect(
                 () =>
-                    new ZeroEx(provider, {
+                    new ContractWrappers(provider, {
                         networkId: UNKNOWN_NETWORK_NETWORK_ID,
                     } as any),
             ).to.throw();
@@ -86,16 +85,23 @@ describe('EtherTokenWrapper', () => {
     });
     describe('#depositAsync', () => {
         it('should successfully deposit ETH and issue Wrapped ETH tokens', async () => {
-            const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
-            const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+            const preETHBalance = await web3Wrapper.getBalanceInWeiAsync(addressWithETH);
+            const preWETHBalance = await contractWrappers.token.getBalanceAsync(wethContractAddress, addressWithETH);
             expect(preETHBalance).to.be.bignumber.gt(0);
             expect(preWETHBalance).to.be.bignumber.equal(0);
 
-            const txHash = await zeroEx.etherToken.depositAsync(wethContractAddress, depositWeiAmount, addressWithETH);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const txHash = await contractWrappers.etherToken.depositAsync(
+                wethContractAddress,
+                depositWeiAmount,
+                addressWithETH,
+            );
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
 
-            const postETHBalanceInWei = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
-            const postWETHBalanceInBaseUnits = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+            const postETHBalanceInWei = await web3Wrapper.getBalanceInWeiAsync(addressWithETH);
+            const postWETHBalanceInBaseUnits = await contractWrappers.token.getBalanceAsync(
+                wethContractAddress,
+                addressWithETH,
+            );
 
             expect(postWETHBalanceInBaseUnits).to.be.bignumber.equal(depositWeiAmount);
             const remainingETHInWei = preETHBalance.minus(depositWeiAmount);
@@ -103,34 +109,41 @@ describe('EtherTokenWrapper', () => {
             expect(gasCost).to.be.bignumber.lte(MAX_REASONABLE_GAS_COST_IN_WEI);
         });
         it('should throw if user has insufficient ETH balance for deposit', async () => {
-            const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
+            const preETHBalance = await web3Wrapper.getBalanceInWeiAsync(addressWithETH);
 
             const extraETHBalance = Web3Wrapper.toWei(new BigNumber(5));
             const overETHBalanceinWei = preETHBalance.add(extraETHBalance);
 
             return expect(
-                zeroEx.etherToken.depositAsync(wethContractAddress, overETHBalanceinWei, addressWithETH),
-            ).to.be.rejectedWith(ZeroExError.InsufficientEthBalanceForDeposit);
+                contractWrappers.etherToken.depositAsync(wethContractAddress, overETHBalanceinWei, addressWithETH),
+            ).to.be.rejectedWith(ContractWrappersError.InsufficientEthBalanceForDeposit);
         });
     });
     describe('#withdrawAsync', () => {
         it('should successfully withdraw ETH in return for Wrapped ETH tokens', async () => {
-            const ETHBalanceInWei = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
+            const ETHBalanceInWei = await web3Wrapper.getBalanceInWeiAsync(addressWithETH);
 
-            await zeroEx.etherToken.depositAsync(wethContractAddress, depositWeiAmount, addressWithETH);
+            await contractWrappers.etherToken.depositAsync(wethContractAddress, depositWeiAmount, addressWithETH);
 
             const expectedPreETHBalance = ETHBalanceInWei.minus(depositWeiAmount);
-            const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
-            const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+            const preETHBalance = await web3Wrapper.getBalanceInWeiAsync(addressWithETH);
+            const preWETHBalance = await contractWrappers.token.getBalanceAsync(wethContractAddress, addressWithETH);
             let gasCost = expectedPreETHBalance.minus(preETHBalance);
             expect(gasCost).to.be.bignumber.lte(MAX_REASONABLE_GAS_COST_IN_WEI);
             expect(preWETHBalance).to.be.bignumber.equal(depositWeiAmount);
 
-            const txHash = await zeroEx.etherToken.withdrawAsync(wethContractAddress, depositWeiAmount, addressWithETH);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const txHash = await contractWrappers.etherToken.withdrawAsync(
+                wethContractAddress,
+                depositWeiAmount,
+                addressWithETH,
+            );
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
 
-            const postETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
-            const postWETHBalanceInBaseUnits = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+            const postETHBalance = await web3Wrapper.getBalanceInWeiAsync(addressWithETH);
+            const postWETHBalanceInBaseUnits = await contractWrappers.token.getBalanceAsync(
+                wethContractAddress,
+                addressWithETH,
+            );
 
             expect(postWETHBalanceInBaseUnits).to.be.bignumber.equal(0);
             const expectedETHBalance = preETHBalance.add(depositWeiAmount).round(decimalPlaces);
@@ -138,14 +151,15 @@ describe('EtherTokenWrapper', () => {
             expect(gasCost).to.be.bignumber.lte(MAX_REASONABLE_GAS_COST_IN_WEI);
         });
         it('should throw if user has insufficient WETH balance for withdrawal', async () => {
-            const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+            const preWETHBalance = await contractWrappers.token.getBalanceAsync(wethContractAddress, addressWithETH);
             expect(preWETHBalance).to.be.bignumber.equal(0);
 
+            // tslint:disable-next-line:custom-no-magic-numbers
             const overWETHBalance = preWETHBalance.add(999999999);
 
             return expect(
-                zeroEx.etherToken.withdrawAsync(wethContractAddress, overWETHBalance, addressWithETH),
-            ).to.be.rejectedWith(ZeroExError.InsufficientWEthBalanceForWithdrawal);
+                contractWrappers.etherToken.withdrawAsync(wethContractAddress, overWETHBalance, addressWithETH),
+            ).to.be.rejectedWith(ContractWrappersError.InsufficientWEthBalanceForWithdrawal);
         });
     });
     describe('#subscribe', () => {
@@ -157,7 +171,7 @@ describe('EtherTokenWrapper', () => {
             etherTokenAddress = etherToken.address;
         });
         afterEach(() => {
-            zeroEx.etherToken.unsubscribeAll();
+            contractWrappers.etherToken.unsubscribeAll();
         });
         // Hack: Mocha does not allow a test to be both async and have a `done` callback
         // Since we need to await the receipt of the event in the `subscribe` callback,
@@ -166,7 +180,7 @@ describe('EtherTokenWrapper', () => {
         // Source: https://github.com/mochajs/mocha/issues/2407
         it('Should receive the Transfer event when tokens are transfered', (done: DoneCallback) => {
             (async () => {
-                const callback = reportNodeCallbackErrors(done)(
+                const callback = callbackErrorReporter.reportNodeCallbackErrors(done)(
                     (logEvent: DecodedLogEvent<TransferContractEventArgs>) => {
                         expect(logEvent).to.not.be.undefined();
                         expect(logEvent.isRemoved).to.be.false();
@@ -179,9 +193,14 @@ describe('EtherTokenWrapper', () => {
                         expect(args._value).to.be.bignumber.equal(transferAmount);
                     },
                 );
-                await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
-                zeroEx.etherToken.subscribe(etherTokenAddress, EtherTokenEvents.Transfer, indexFilterValues, callback);
-                await zeroEx.token.transferAsync(
+                await contractWrappers.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
+                contractWrappers.etherToken.subscribe(
+                    etherTokenAddress,
+                    EtherTokenEvents.Transfer,
+                    indexFilterValues,
+                    callback,
+                );
+                await contractWrappers.token.transferAsync(
                     etherTokenAddress,
                     addressWithETH,
                     addressWithoutFunds,
@@ -191,7 +210,7 @@ describe('EtherTokenWrapper', () => {
         });
         it('Should receive the Approval event when allowance is being set', (done: DoneCallback) => {
             (async () => {
-                const callback = reportNodeCallbackErrors(done)(
+                const callback = callbackErrorReporter.reportNodeCallbackErrors(done)(
                     (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
                         expect(logEvent).to.not.be.undefined();
                         expect(logEvent.isRemoved).to.be.false();
@@ -201,8 +220,13 @@ describe('EtherTokenWrapper', () => {
                         expect(args._value).to.be.bignumber.equal(allowanceAmount);
                     },
                 );
-                zeroEx.etherToken.subscribe(etherTokenAddress, EtherTokenEvents.Approval, indexFilterValues, callback);
-                await zeroEx.token.setAllowanceAsync(
+                contractWrappers.etherToken.subscribe(
+                    etherTokenAddress,
+                    EtherTokenEvents.Approval,
+                    indexFilterValues,
+                    callback,
+                );
+                await contractWrappers.token.setAllowanceAsync(
                     etherTokenAddress,
                     addressWithETH,
                     addressWithoutFunds,
@@ -212,7 +236,7 @@ describe('EtherTokenWrapper', () => {
         });
         it('Should receive the Deposit event when ether is being deposited', (done: DoneCallback) => {
             (async () => {
-                const callback = reportNodeCallbackErrors(done)(
+                const callback = callbackErrorReporter.reportNodeCallbackErrors(done)(
                     (logEvent: DecodedLogEvent<DepositContractEventArgs>) => {
                         expect(logEvent).to.not.be.undefined();
                         expect(logEvent.isRemoved).to.be.false();
@@ -221,13 +245,18 @@ describe('EtherTokenWrapper', () => {
                         expect(args._value).to.be.bignumber.equal(depositAmount);
                     },
                 );
-                zeroEx.etherToken.subscribe(etherTokenAddress, EtherTokenEvents.Deposit, indexFilterValues, callback);
-                await zeroEx.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
+                contractWrappers.etherToken.subscribe(
+                    etherTokenAddress,
+                    EtherTokenEvents.Deposit,
+                    indexFilterValues,
+                    callback,
+                );
+                await contractWrappers.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
             })().catch(done);
         });
         it('Should receive the Withdrawal event when ether is being withdrawn', (done: DoneCallback) => {
             (async () => {
-                const callback = reportNodeCallbackErrors(done)(
+                const callback = callbackErrorReporter.reportNodeCallbackErrors(done)(
                     (logEvent: DecodedLogEvent<WithdrawalContractEventArgs>) => {
                         expect(logEvent).to.not.be.undefined();
                         expect(logEvent.isRemoved).to.be.false();
@@ -236,39 +265,39 @@ describe('EtherTokenWrapper', () => {
                         expect(args._value).to.be.bignumber.equal(depositAmount);
                     },
                 );
-                await zeroEx.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
-                zeroEx.etherToken.subscribe(
+                await contractWrappers.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
+                contractWrappers.etherToken.subscribe(
                     etherTokenAddress,
                     EtherTokenEvents.Withdrawal,
                     indexFilterValues,
                     callback,
                 );
-                await zeroEx.etherToken.withdrawAsync(etherTokenAddress, withdrawalAmount, addressWithETH);
+                await contractWrappers.etherToken.withdrawAsync(etherTokenAddress, withdrawalAmount, addressWithETH);
             })().catch(done);
         });
         it('should cancel outstanding subscriptions when ZeroEx.setProvider is called', (done: DoneCallback) => {
             (async () => {
-                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
+                const callbackNeverToBeCalled = callbackErrorReporter.reportNodeCallbackErrors(done)(
                     (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
                         done(new Error('Expected this subscription to have been cancelled'));
                     },
                 );
-                zeroEx.etherToken.subscribe(
+                contractWrappers.etherToken.subscribe(
                     etherTokenAddress,
                     EtherTokenEvents.Transfer,
                     indexFilterValues,
                     callbackNeverToBeCalled,
                 );
-                const callbackToBeCalled = reportNodeCallbackErrors(done)();
-                zeroEx.setProvider(provider, constants.TESTRPC_NETWORK_ID);
-                await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
-                zeroEx.etherToken.subscribe(
+                const callbackToBeCalled = callbackErrorReporter.reportNodeCallbackErrors(done)();
+                contractWrappers.setProvider(provider, constants.TESTRPC_NETWORK_ID);
+                await contractWrappers.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
+                contractWrappers.etherToken.subscribe(
                     etherTokenAddress,
                     EtherTokenEvents.Transfer,
                     indexFilterValues,
                     callbackToBeCalled,
                 );
-                await zeroEx.token.transferAsync(
+                await contractWrappers.token.transferAsync(
                     etherTokenAddress,
                     addressWithETH,
                     addressWithoutFunds,
@@ -278,20 +307,20 @@ describe('EtherTokenWrapper', () => {
         });
         it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
             (async () => {
-                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
+                const callbackNeverToBeCalled = callbackErrorReporter.reportNodeCallbackErrors(done)(
                     (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
                         done(new Error('Expected this subscription to have been cancelled'));
                     },
                 );
-                await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
-                const subscriptionToken = zeroEx.etherToken.subscribe(
+                await contractWrappers.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
+                const subscriptionToken = contractWrappers.etherToken.subscribe(
                     etherTokenAddress,
                     EtherTokenEvents.Transfer,
                     indexFilterValues,
                     callbackNeverToBeCalled,
                 );
-                zeroEx.etherToken.unsubscribe(subscriptionToken);
-                await zeroEx.token.transferAsync(
+                contractWrappers.etherToken.unsubscribe(subscriptionToken);
+                await contractWrappers.token.transferAsync(
                     etherTokenAddress,
                     addressWithETH,
                     addressWithoutFunds,
@@ -314,14 +343,14 @@ describe('EtherTokenWrapper', () => {
             const tokenUtils = new TokenUtils(tokens);
             const etherToken = tokenUtils.getWethTokenOrThrow();
             etherTokenAddress = etherToken.address;
-            tokenTransferProxyAddress = zeroEx.proxy.getContractAddress();
+            tokenTransferProxyAddress = contractWrappers.proxy.getContractAddress();
         });
         it('should get logs with decoded args emitted by Approval', async () => {
-            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            txHash = await contractWrappers.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
             const eventName = EtherTokenEvents.Approval;
             const indexFilterValues = {};
-            const logs = await zeroEx.etherToken.getLogsAsync<ApprovalContractEventArgs>(
+            const logs = await contractWrappers.etherToken.getLogsAsync<ApprovalContractEventArgs>(
                 etherTokenAddress,
                 eventName,
                 blockRange,
@@ -332,13 +361,13 @@ describe('EtherTokenWrapper', () => {
             expect(logs[0].event).to.be.equal(eventName);
             expect(args._owner).to.be.equal(addressWithETH);
             expect(args._spender).to.be.equal(tokenTransferProxyAddress);
-            expect(args._value).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+            expect(args._value).to.be.bignumber.equal(contractWrappers.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
         });
         it('should get logs with decoded args emitted by Deposit', async () => {
-            await zeroEx.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
+            await contractWrappers.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
             const eventName = EtherTokenEvents.Deposit;
             const indexFilterValues = {};
-            const logs = await zeroEx.etherToken.getLogsAsync<DepositContractEventArgs>(
+            const logs = await contractWrappers.etherToken.getLogsAsync<DepositContractEventArgs>(
                 etherTokenAddress,
                 eventName,
                 blockRange,
@@ -351,11 +380,11 @@ describe('EtherTokenWrapper', () => {
             expect(args._value).to.be.bignumber.equal(depositAmount);
         });
         it('should only get the logs with the correct event name', async () => {
-            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            txHash = await contractWrappers.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
             const differentEventName = EtherTokenEvents.Transfer;
             const indexFilterValues = {};
-            const logs = await zeroEx.etherToken.getLogsAsync(
+            const logs = await contractWrappers.etherToken.getLogsAsync(
                 etherTokenAddress,
                 differentEventName,
                 blockRange,
@@ -364,15 +393,18 @@ describe('EtherTokenWrapper', () => {
             expect(logs).to.have.length(0);
         });
         it('should only get the logs with the correct indexed fields', async () => {
-            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithoutFunds);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            txHash = await contractWrappers.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
+            txHash = await contractWrappers.token.setUnlimitedProxyAllowanceAsync(
+                etherTokenAddress,
+                addressWithoutFunds,
+            );
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
             const eventName = EtherTokenEvents.Approval;
             const indexFilterValues = {
                 _owner: addressWithETH,
             };
-            const logs = await zeroEx.etherToken.getLogsAsync<ApprovalContractEventArgs>(
+            const logs = await contractWrappers.etherToken.getLogsAsync<ApprovalContractEventArgs>(
                 etherTokenAddress,
                 eventName,
                 blockRange,

packages/contract-wrappers/test/exchange_transfer_simulator_test.ts

@@ -1,9 +1,10 @@
 import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
-import { BlockParamLiteral } from '@0xproject/types';
+import { BlockParamLiteral, Token } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
+import 'make-promises-safe';
 
-import { ExchangeContractErrs, Token, ZeroEx } from '../src';
+import { ContractWrappers, ExchangeContractErrs } from '../src';
 import { TradeSide, TransferType } from '../src/types';
 import { ExchangeTransferSimulator } from '../src/utils/exchange_transfer_simulator';
 
@@ -19,7 +20,7 @@ describe('ExchangeTransferSimulator', () => {
     const config = {
         networkId: constants.TESTRPC_NETWORK_ID,
     };
-    const zeroEx = new ZeroEx(provider, config);
+    const contractWrappers = new ContractWrappers(provider, config);
     const transferAmount = new BigNumber(5);
     let userAddresses: string[];
     let tokens: Token[];
@@ -30,9 +31,9 @@ describe('ExchangeTransferSimulator', () => {
     let exchangeTransferSimulator: ExchangeTransferSimulator;
     let txHash: string;
     before(async () => {
-        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        userAddresses = await web3Wrapper.getAvailableAddressesAsync();
         [coinbase, sender, recipient] = userAddresses;
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        tokens = await contractWrappers.tokenRegistry.getTokensAsync();
         exampleTokenAddress = tokens[0].address;
     });
     beforeEach(async () => {
@@ -43,7 +44,7 @@ describe('ExchangeTransferSimulator', () => {
     });
     describe('#transferFromAsync', () => {
         beforeEach(() => {
-            exchangeTransferSimulator = new ExchangeTransferSimulator(zeroEx.token, BlockParamLiteral.Latest);
+            exchangeTransferSimulator = new ExchangeTransferSimulator(contractWrappers.token, BlockParamLiteral.Latest);
         });
         it("throws if the user doesn't have enough allowance", async () => {
             return expect(
@@ -58,8 +59,8 @@ describe('ExchangeTransferSimulator', () => {
             ).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerAllowance);
         });
         it("throws if the user doesn't have enough balance", async () => {
-            txHash = await zeroEx.token.setProxyAllowanceAsync(exampleTokenAddress, sender, transferAmount);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            txHash = await contractWrappers.token.setProxyAllowanceAsync(exampleTokenAddress, sender, transferAmount);
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
             return expect(
                 exchangeTransferSimulator.transferFromAsync(
                     exampleTokenAddress,
@@ -72,10 +73,10 @@ describe('ExchangeTransferSimulator', () => {
             ).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerBalance);
         });
         it('updates balances and proxyAllowance after transfer', async () => {
-            txHash = await zeroEx.token.transferAsync(exampleTokenAddress, coinbase, sender, transferAmount);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            txHash = await zeroEx.token.setProxyAllowanceAsync(exampleTokenAddress, sender, transferAmount);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            txHash = await contractWrappers.token.transferAsync(exampleTokenAddress, coinbase, sender, transferAmount);
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
+            txHash = await contractWrappers.token.setProxyAllowanceAsync(exampleTokenAddress, sender, transferAmount);
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
             await exchangeTransferSimulator.transferFromAsync(
                 exampleTokenAddress,
                 sender,
@@ -93,10 +94,10 @@ describe('ExchangeTransferSimulator', () => {
             expect(senderProxyAllowance).to.be.bignumber.equal(0);
         });
         it("doesn't update proxyAllowance after transfer if unlimited", async () => {
-            txHash = await zeroEx.token.transferAsync(exampleTokenAddress, coinbase, sender, transferAmount);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(exampleTokenAddress, sender);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            txHash = await contractWrappers.token.transferAsync(exampleTokenAddress, coinbase, sender, transferAmount);
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
+            txHash = await contractWrappers.token.setUnlimitedProxyAllowanceAsync(exampleTokenAddress, sender);
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
             await exchangeTransferSimulator.transferFromAsync(
                 exampleTokenAddress,
                 sender,
@@ -111,7 +112,9 @@ describe('ExchangeTransferSimulator', () => {
             const senderProxyAllowance = await store.getProxyAllowanceAsync(exampleTokenAddress, sender);
             expect(senderBalance).to.be.bignumber.equal(0);
             expect(recipientBalance).to.be.bignumber.equal(transferAmount);
-            expect(senderProxyAllowance).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+            expect(senderProxyAllowance).to.be.bignumber.equal(
+                contractWrappers.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS,
+            );
         });
     });
 });

packages/contract-wrappers/test/exchange_wrapper_test.ts

@@ -1,12 +1,17 @@
-import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
-import { BlockParamLiteral } from '@0xproject/types';
+import { BlockchainLifecycle, callbackErrorReporter, devConstants, web3Factory } from '@0xproject/dev-utils';
+import { FillScenarios } from '@0xproject/fill-scenarios';
+import { getOrderHashHex } from '@0xproject/order-utils';
+import { BlockParamLiteral, DoneCallback, OrderState } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as chai from 'chai';
 import * as _ from 'lodash';
+import 'make-promises-safe';
 import 'mocha';
 
 import {
     BlockRange,
+    ContractWrappers,
     DecodedLogEvent,
     ExchangeContractErrs,
     ExchangeEvents,
@@ -14,17 +19,12 @@ import {
     LogFillContractEventArgs,
     OrderCancellationRequest,
     OrderFillRequest,
-    OrderState,
     SignedOrder,
     Token,
-    ZeroEx,
 } from '../src';
-import { DoneCallback } from '../src/types';
 
 import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
-import { FillScenarios } from './utils/fill_scenarios';
-import { reportNodeCallbackErrors } from './utils/report_callback_errors';
 import { TokenUtils } from './utils/token_utils';
 import { provider, web3Wrapper } from './utils/web3_wrapper';
 
@@ -35,7 +35,7 @@ const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 const NON_EXISTENT_ORDER_HASH = '0x79370342234e7acd6bbeac335bd3bb1d368383294b64b8160a00f4060e4d3777';
 
 describe('ExchangeWrapper', () => {
-    let zeroEx: ZeroEx;
+    let contractWrappers: ContractWrappers;
     let tokenUtils: TokenUtils;
     let tokens: Token[];
     let userAddresses: string[];
@@ -46,13 +46,13 @@ describe('ExchangeWrapper', () => {
         networkId: constants.TESTRPC_NETWORK_ID,
     };
     before(async () => {
-        zeroEx = new ZeroEx(provider, config);
-        exchangeContractAddress = zeroEx.exchange.getContractAddress();
-        userAddresses = await zeroEx.getAvailableAddressesAsync();
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        contractWrappers = new ContractWrappers(provider, config);
+        exchangeContractAddress = contractWrappers.exchange.getContractAddress();
+        userAddresses = await web3Wrapper.getAvailableAddressesAsync();
+        tokens = await contractWrappers.tokenRegistry.getTokensAsync();
         tokenUtils = new TokenUtils(tokens);
         zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
-        fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
+        fillScenarios = new FillScenarios(provider, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
         await fillScenarios.initTokenBalancesAsync();
     });
     beforeEach(async () => {
@@ -71,7 +71,7 @@ describe('ExchangeWrapper', () => {
         const takerTokenFillAmount = new BigNumber(5);
         before(async () => {
             [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
-            tokens = await zeroEx.tokenRegistry.getTokensAsync();
+            tokens = await contractWrappers.tokenRegistry.getTokensAsync();
             const [makerToken, takerToken] = tokenUtils.getDummyTokens();
             makerTokenAddress = makerToken.address;
             takerTokenAddress = takerToken.address;
@@ -104,7 +104,7 @@ describe('ExchangeWrapper', () => {
                         takerTokenFillAmount: partialFillTakerAmount,
                     },
                 ];
-                await zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress);
+                await contractWrappers.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress);
             });
             describe('order transaction options', () => {
                 let signedOrder: SignedOrder;
@@ -127,19 +127,19 @@ describe('ExchangeWrapper', () => {
                 });
                 it('should validate when orderTransactionOptions are not present', async () => {
                     return expect(
-                        zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress),
+                        contractWrappers.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress),
                     ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
                 });
                 it('should validate when orderTransactionOptions specify to validate', async () => {
                     return expect(
-                        zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress, {
+                        contractWrappers.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress, {
                             shouldValidate: true,
                         }),
                     ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
                 });
                 it('should not validate when orderTransactionOptions specify not to validate', async () => {
                     return expect(
-                        zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress, {
+                        contractWrappers.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress, {
                             shouldValidate: false,
                         }),
                     ).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
@@ -160,66 +160,70 @@ describe('ExchangeWrapper', () => {
             });
             describe('successful fills', () => {
                 it('should fill a valid order', async () => {
-                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
-                        fillableAmount,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
-                        0,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
-                        0,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
-                        fillableAmount,
-                    );
-                    await zeroEx.exchange.fillOrKillOrderAsync(signedOrder, takerTokenFillAmount, takerAddress);
-                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
-                        fillableAmount.minus(takerTokenFillAmount),
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(makerTokenAddress, makerAddress),
+                    ).to.be.bignumber.equal(fillableAmount);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(takerTokenAddress, makerAddress),
+                    ).to.be.bignumber.equal(0);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(makerTokenAddress, takerAddress),
+                    ).to.be.bignumber.equal(0);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(takerTokenAddress, takerAddress),
+                    ).to.be.bignumber.equal(fillableAmount);
+                    await contractWrappers.exchange.fillOrKillOrderAsync(
+                        signedOrder,
                         takerTokenFillAmount,
+                        takerAddress,
                     );
-                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
-                        takerTokenFillAmount,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
-                        fillableAmount.minus(takerTokenFillAmount),
-                    );
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(makerTokenAddress, makerAddress),
+                    ).to.be.bignumber.equal(fillableAmount.minus(takerTokenFillAmount));
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(takerTokenAddress, makerAddress),
+                    ).to.be.bignumber.equal(takerTokenFillAmount);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(makerTokenAddress, takerAddress),
+                    ).to.be.bignumber.equal(takerTokenFillAmount);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(takerTokenAddress, takerAddress),
+                    ).to.be.bignumber.equal(fillableAmount.minus(takerTokenFillAmount));
                 });
                 it('should partially fill a valid order', async () => {
                     const partialFillAmount = new BigNumber(3);
-                    await zeroEx.exchange.fillOrKillOrderAsync(signedOrder, partialFillAmount, takerAddress);
-                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
-                        fillableAmount.minus(partialFillAmount),
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
-                        partialFillAmount,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
-                        partialFillAmount,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
-                        fillableAmount.minus(partialFillAmount),
-                    );
+                    await contractWrappers.exchange.fillOrKillOrderAsync(signedOrder, partialFillAmount, takerAddress);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(makerTokenAddress, makerAddress),
+                    ).to.be.bignumber.equal(fillableAmount.minus(partialFillAmount));
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(takerTokenAddress, makerAddress),
+                    ).to.be.bignumber.equal(partialFillAmount);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(makerTokenAddress, takerAddress),
+                    ).to.be.bignumber.equal(partialFillAmount);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(takerTokenAddress, takerAddress),
+                    ).to.be.bignumber.equal(fillableAmount.minus(partialFillAmount));
                 });
             });
             describe('order transaction options', () => {
                 const emptyFillableAmount = new BigNumber(0);
                 it('should validate when orderTransactionOptions are not present', async () => {
                     return expect(
-                        zeroEx.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress),
+                        contractWrappers.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress),
                     ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
                 });
                 it('should validate when orderTransactionOptions specify to validate', async () => {
                     return expect(
-                        zeroEx.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress, {
+                        contractWrappers.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress, {
                             shouldValidate: true,
                         }),
                     ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
                 });
                 it('should not validate when orderTransactionOptions specify not to validate', async () => {
                     return expect(
-                        zeroEx.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress, {
+                        contractWrappers.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress, {
                             shouldValidate: false,
                         }),
                     ).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
@@ -239,7 +243,7 @@ describe('ExchangeWrapper', () => {
         const shouldThrowOnInsufficientBalanceOrAllowance = true;
         before(async () => {
             [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
-            tokens = await zeroEx.tokenRegistry.getTokensAsync();
+            tokens = await contractWrappers.tokenRegistry.getTokensAsync();
             const [makerToken, takerToken] = tokenUtils.getDummyTokens();
             makerTokenAddress = makerToken.address;
             takerTokenAddress = takerToken.address;
@@ -254,37 +258,37 @@ describe('ExchangeWrapper', () => {
                         takerAddress,
                         fillableAmount,
                     );
-                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
-                        fillableAmount,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
-                        0,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
-                        0,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
-                        fillableAmount,
-                    );
-                    const txHash = await zeroEx.exchange.fillOrderAsync(
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(makerTokenAddress, makerAddress),
+                    ).to.be.bignumber.equal(fillableAmount);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(takerTokenAddress, makerAddress),
+                    ).to.be.bignumber.equal(0);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(makerTokenAddress, takerAddress),
+                    ).to.be.bignumber.equal(0);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(takerTokenAddress, takerAddress),
+                    ).to.be.bignumber.equal(fillableAmount);
+                    const txHash = await contractWrappers.exchange.fillOrderAsync(
                         signedOrder,
                         takerTokenFillAmount,
                         shouldThrowOnInsufficientBalanceOrAllowance,
                         takerAddress,
                     );
-                    await zeroEx.awaitTransactionMinedAsync(txHash);
-                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
-                        fillableAmount.minus(takerTokenFillAmount),
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
-                        takerTokenFillAmount,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
-                        takerTokenFillAmount,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
-                        fillableAmount.minus(takerTokenFillAmount),
-                    );
+                    await web3Wrapper.awaitTransactionMinedAsync(txHash);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(makerTokenAddress, makerAddress),
+                    ).to.be.bignumber.equal(fillableAmount.minus(takerTokenFillAmount));
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(takerTokenAddress, makerAddress),
+                    ).to.be.bignumber.equal(takerTokenFillAmount);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(makerTokenAddress, takerAddress),
+                    ).to.be.bignumber.equal(takerTokenFillAmount);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(takerTokenAddress, takerAddress),
+                    ).to.be.bignumber.equal(fillableAmount.minus(takerTokenFillAmount));
                 });
                 it('should partially fill the valid order', async () => {
                     const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
@@ -295,25 +299,25 @@ describe('ExchangeWrapper', () => {
                         fillableAmount,
                     );
                     const partialFillAmount = new BigNumber(3);
-                    const txHash = await zeroEx.exchange.fillOrderAsync(
+                    const txHash = await contractWrappers.exchange.fillOrderAsync(
                         signedOrder,
                         partialFillAmount,
                         shouldThrowOnInsufficientBalanceOrAllowance,
                         takerAddress,
                     );
-                    await zeroEx.awaitTransactionMinedAsync(txHash);
-                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
-                        fillableAmount.minus(partialFillAmount),
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
-                        partialFillAmount,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
-                        partialFillAmount,
-                    );
-                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
-                        fillableAmount.minus(partialFillAmount),
-                    );
+                    await web3Wrapper.awaitTransactionMinedAsync(txHash);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(makerTokenAddress, makerAddress),
+                    ).to.be.bignumber.equal(fillableAmount.minus(partialFillAmount));
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(takerTokenAddress, makerAddress),
+                    ).to.be.bignumber.equal(partialFillAmount);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(makerTokenAddress, takerAddress),
+                    ).to.be.bignumber.equal(partialFillAmount);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(takerTokenAddress, takerAddress),
+                    ).to.be.bignumber.equal(fillableAmount.minus(partialFillAmount));
                 });
                 it('should fill the valid orders with fees', async () => {
                     const makerFee = new BigNumber(1);
@@ -328,16 +332,16 @@ describe('ExchangeWrapper', () => {
                         fillableAmount,
                         feeRecipient,
                     );
-                    const txHash = await zeroEx.exchange.fillOrderAsync(
+                    const txHash = await contractWrappers.exchange.fillOrderAsync(
                         signedOrder,
                         takerTokenFillAmount,
                         shouldThrowOnInsufficientBalanceOrAllowance,
                         takerAddress,
                     );
-                    await zeroEx.awaitTransactionMinedAsync(txHash);
-                    expect(await zeroEx.token.getBalanceAsync(zrxTokenAddress, feeRecipient)).to.be.bignumber.equal(
-                        makerFee.plus(takerFee),
-                    );
+                    await web3Wrapper.awaitTransactionMinedAsync(txHash);
+                    expect(
+                        await contractWrappers.token.getBalanceAsync(zrxTokenAddress, feeRecipient),
+                    ).to.be.bignumber.equal(makerFee.plus(takerFee));
                 });
             });
             describe('order transaction options', () => {
@@ -354,7 +358,7 @@ describe('ExchangeWrapper', () => {
                 });
                 it('should validate when orderTransactionOptions are not present', async () => {
                     return expect(
-                        zeroEx.exchange.fillOrderAsync(
+                        contractWrappers.exchange.fillOrderAsync(
                             signedOrder,
                             emptyFillTakerAmount,
                             shouldThrowOnInsufficientBalanceOrAllowance,
@@ -364,7 +368,7 @@ describe('ExchangeWrapper', () => {
                 });
                 it('should validate when orderTransactionOptions specify to validate', async () => {
                     return expect(
-                        zeroEx.exchange.fillOrderAsync(
+                        contractWrappers.exchange.fillOrderAsync(
                             signedOrder,
                             emptyFillTakerAmount,
                             shouldThrowOnInsufficientBalanceOrAllowance,
@@ -377,7 +381,7 @@ describe('ExchangeWrapper', () => {
                 });
                 it('should not validate when orderTransactionOptions specify not to validate', async () => {
                     return expect(
-                        zeroEx.exchange.fillOrderAsync(
+                        contractWrappers.exchange.fillOrderAsync(
                             signedOrder,
                             emptyFillTakerAmount,
                             shouldThrowOnInsufficientBalanceOrAllowance,
@@ -403,7 +407,7 @@ describe('ExchangeWrapper', () => {
                 });
                 it('should not allow the exchange wrapper to fill if amount is negative', async () => {
                     return expect(
-                        zeroEx.exchange.fillOrderAsync(
+                        contractWrappers.exchange.fillOrderAsync(
                             signedOrder,
                             negativeFillTakerAmount,
                             shouldThrowOnInsufficientBalanceOrAllowance,
@@ -427,7 +431,7 @@ describe('ExchangeWrapper', () => {
                     takerAddress,
                     fillableAmount,
                 );
-                signedOrderHashHex = ZeroEx.getOrderHashHex(signedOrder);
+                signedOrderHashHex = getOrderHashHex(signedOrder);
                 anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
                     makerTokenAddress,
                     takerTokenAddress,
@@ -435,7 +439,7 @@ describe('ExchangeWrapper', () => {
                     takerAddress,
                     fillableAmount,
                 );
-                anotherOrderHashHex = ZeroEx.getOrderHashHex(anotherSignedOrder);
+                anotherOrderHashHex = getOrderHashHex(anotherSignedOrder);
             });
             describe('successful batch fills', () => {
                 beforeEach(() => {
@@ -452,7 +456,7 @@ describe('ExchangeWrapper', () => {
                 });
                 it('should throw if a batch is empty', async () => {
                     return expect(
-                        zeroEx.exchange.batchFillOrdersAsync(
+                        contractWrappers.exchange.batchFillOrdersAsync(
                             [],
                             shouldThrowOnInsufficientBalanceOrAllowance,
                             takerAddress,
@@ -460,14 +464,16 @@ describe('ExchangeWrapper', () => {
                     ).to.be.rejectedWith(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
                 });
                 it('should successfully fill multiple orders', async () => {
-                    const txHash = await zeroEx.exchange.batchFillOrdersAsync(
+                    const txHash = await contractWrappers.exchange.batchFillOrdersAsync(
                         orderFillBatch,
                         shouldThrowOnInsufficientBalanceOrAllowance,
                         takerAddress,
                     );
-                    await zeroEx.awaitTransactionMinedAsync(txHash);
-                    const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
-                    const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
+                    await web3Wrapper.awaitTransactionMinedAsync(txHash);
+                    const filledAmount = await contractWrappers.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
+                    const anotherFilledAmount = await contractWrappers.exchange.getFilledTakerAmountAsync(
+                        anotherOrderHashHex,
+                    );
                     expect(filledAmount).to.be.bignumber.equal(takerTokenFillAmount);
                     expect(anotherFilledAmount).to.be.bignumber.equal(takerTokenFillAmount);
                 });
@@ -488,7 +494,7 @@ describe('ExchangeWrapper', () => {
                 });
                 it('should validate when orderTransactionOptions are not present', async () => {
                     return expect(
-                        zeroEx.exchange.batchFillOrdersAsync(
+                        contractWrappers.exchange.batchFillOrdersAsync(
                             orderFillBatch,
                             shouldThrowOnInsufficientBalanceOrAllowance,
                             takerAddress,
@@ -497,7 +503,7 @@ describe('ExchangeWrapper', () => {
                 });
                 it('should validate when orderTransactionOptions specify to validate', async () => {
                     return expect(
-                        zeroEx.exchange.batchFillOrdersAsync(
+                        contractWrappers.exchange.batchFillOrdersAsync(
                             orderFillBatch,
                             shouldThrowOnInsufficientBalanceOrAllowance,
                             takerAddress,
@@ -509,7 +515,7 @@ describe('ExchangeWrapper', () => {
                 });
                 it('should not validate when orderTransactionOptions specify not to validate', async () => {
                     return expect(
-                        zeroEx.exchange.batchFillOrdersAsync(
+                        contractWrappers.exchange.batchFillOrdersAsync(
                             orderFillBatch,
                             shouldThrowOnInsufficientBalanceOrAllowance,
                             takerAddress,
@@ -536,7 +542,7 @@ describe('ExchangeWrapper', () => {
                 });
                 it('should not allow the exchange wrapper to batch fill if any amount is negative', async () => {
                     return expect(
-                        zeroEx.exchange.batchFillOrdersAsync(
+                        contractWrappers.exchange.batchFillOrdersAsync(
                             orderFillBatch,
                             shouldThrowOnInsufficientBalanceOrAllowance,
                             takerAddress,
@@ -560,7 +566,7 @@ describe('ExchangeWrapper', () => {
                     takerAddress,
                     fillableAmount,
                 );
-                signedOrderHashHex = ZeroEx.getOrderHashHex(signedOrder);
+                signedOrderHashHex = getOrderHashHex(signedOrder);
                 anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
                     makerTokenAddress,
                     takerTokenAddress,
@@ -568,13 +574,13 @@ describe('ExchangeWrapper', () => {
                     takerAddress,
                     fillableAmount,
                 );
-                anotherOrderHashHex = ZeroEx.getOrderHashHex(anotherSignedOrder);
+                anotherOrderHashHex = getOrderHashHex(anotherSignedOrder);
                 signedOrders = [signedOrder, anotherSignedOrder];
             });
             describe('successful batch fills', () => {
                 it('should throw if a batch is empty', async () => {
                     return expect(
-                        zeroEx.exchange.fillOrdersUpToAsync(
+                        contractWrappers.exchange.fillOrdersUpToAsync(
                             [],
                             fillUpToAmount,
                             shouldThrowOnInsufficientBalanceOrAllowance,
@@ -583,45 +589,54 @@ describe('ExchangeWrapper', () => {
                     ).to.be.rejectedWith(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
                 });
                 it('should successfully fill up to specified amount when all orders are fully funded', async () => {
-                    const txHash = await zeroEx.exchange.fillOrdersUpToAsync(
+                    const txHash = await contractWrappers.exchange.fillOrdersUpToAsync(
                         signedOrders,
                         fillUpToAmount,
                         shouldThrowOnInsufficientBalanceOrAllowance,
                         takerAddress,
                     );
-                    await zeroEx.awaitTransactionMinedAsync(txHash);
-                    const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
-                    const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
+                    await web3Wrapper.awaitTransactionMinedAsync(txHash);
+                    const filledAmount = await contractWrappers.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
+                    const anotherFilledAmount = await contractWrappers.exchange.getFilledTakerAmountAsync(
+                        anotherOrderHashHex,
+                    );
                     expect(filledAmount).to.be.bignumber.equal(fillableAmount);
                     const remainingFillAmount = fillableAmount.minus(1);
                     expect(anotherFilledAmount).to.be.bignumber.equal(remainingFillAmount);
                 });
                 it('should successfully fill up to specified amount and leave the rest of the orders untouched', async () => {
-                    const txHash = await zeroEx.exchange.fillOrdersUpToAsync(
+                    const txHash = await contractWrappers.exchange.fillOrdersUpToAsync(
                         signedOrders,
                         fillableAmount,
                         shouldThrowOnInsufficientBalanceOrAllowance,
                         takerAddress,
                     );
-                    await zeroEx.awaitTransactionMinedAsync(txHash);
-                    const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
-                    const zeroAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
+                    await web3Wrapper.awaitTransactionMinedAsync(txHash);
+                    const filledAmount = await contractWrappers.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
+                    const zeroAmount = await contractWrappers.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
                     expect(filledAmount).to.be.bignumber.equal(fillableAmount);
                     expect(zeroAmount).to.be.bignumber.equal(0);
                 });
                 it('should successfully fill up to specified amount even if filling all orders would fail', async () => {
                     const missingBalance = new BigNumber(1); // User will still have enough balance to fill up to 9,
                     // but won't have 10 to fully fill all orders in a batch.
-                    await zeroEx.token.transferAsync(makerTokenAddress, makerAddress, coinbase, missingBalance);
-                    const txHash = await zeroEx.exchange.fillOrdersUpToAsync(
+                    await contractWrappers.token.transferAsync(
+                        makerTokenAddress,
+                        makerAddress,
+                        coinbase,
+                        missingBalance,
+                    );
+                    const txHash = await contractWrappers.exchange.fillOrdersUpToAsync(
                         signedOrders,
                         fillUpToAmount,
                         shouldThrowOnInsufficientBalanceOrAllowance,
                         takerAddress,
                     );
-                    await zeroEx.awaitTransactionMinedAsync(txHash);
-                    const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
-                    const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
+                    await web3Wrapper.awaitTransactionMinedAsync(txHash);
+                    const filledAmount = await contractWrappers.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
+                    const anotherFilledAmount = await contractWrappers.exchange.getFilledTakerAmountAsync(
+                        anotherOrderHashHex,
+                    );
                     expect(filledAmount).to.be.bignumber.equal(fillableAmount);
                     const remainingFillAmount = fillableAmount.minus(1);
                     expect(anotherFilledAmount).to.be.bignumber.equal(remainingFillAmount);
@@ -630,9 +645,14 @@ describe('ExchangeWrapper', () => {
             describe('failed batch fills', () => {
                 it("should fail validation if user doesn't have enough balance without fill up to", async () => {
                     const missingBalance = new BigNumber(2); // User will only have enough balance to fill up to 8
-                    await zeroEx.token.transferAsync(makerTokenAddress, makerAddress, coinbase, missingBalance);
+                    await contractWrappers.token.transferAsync(
+                        makerTokenAddress,
+                        makerAddress,
+                        coinbase,
+                        missingBalance,
+                    );
                     return expect(
-                        zeroEx.exchange.fillOrdersUpToAsync(
+                        contractWrappers.exchange.fillOrdersUpToAsync(
                             signedOrders,
                             fillUpToAmount,
                             shouldThrowOnInsufficientBalanceOrAllowance,
@@ -645,7 +665,7 @@ describe('ExchangeWrapper', () => {
                 const emptyFillUpToAmount = new BigNumber(0);
                 it('should validate when orderTransactionOptions are not present', async () => {
                     return expect(
-                        zeroEx.exchange.fillOrdersUpToAsync(
+                        contractWrappers.exchange.fillOrdersUpToAsync(
                             signedOrders,
                             emptyFillUpToAmount,
                             shouldThrowOnInsufficientBalanceOrAllowance,
@@ -655,7 +675,7 @@ describe('ExchangeWrapper', () => {
                 });
                 it('should validate when orderTransactionOptions specify to validate', async () => {
                     return expect(
-                        zeroEx.exchange.fillOrdersUpToAsync(
+                        contractWrappers.exchange.fillOrdersUpToAsync(
                             signedOrders,
                             emptyFillUpToAmount,
                             shouldThrowOnInsufficientBalanceOrAllowance,
@@ -668,7 +688,7 @@ describe('ExchangeWrapper', () => {
                 });
                 it('should not validate when orderTransactionOptions specify not to validate', async () => {
                     return expect(
-                        zeroEx.exchange.fillOrdersUpToAsync(
+                        contractWrappers.exchange.fillOrdersUpToAsync(
                             signedOrders,
                             emptyFillUpToAmount,
                             shouldThrowOnInsufficientBalanceOrAllowance,
@@ -704,14 +724,14 @@ describe('ExchangeWrapper', () => {
                 takerAddress,
                 fillableAmount,
             );
-            orderHashHex = ZeroEx.getOrderHashHex(signedOrder);
+            orderHashHex = getOrderHashHex(signedOrder);
         });
         describe('#cancelOrderAsync', () => {
             describe('successful cancels', () => {
                 it('should cancel an order', async () => {
-                    const txHash = await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmount);
-                    await zeroEx.awaitTransactionMinedAsync(txHash);
-                    const cancelledAmount = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHashHex);
+                    const txHash = await contractWrappers.exchange.cancelOrderAsync(signedOrder, cancelAmount);
+                    await web3Wrapper.awaitTransactionMinedAsync(txHash);
+                    const cancelledAmount = await contractWrappers.exchange.getCancelledTakerAmountAsync(orderHashHex);
                     expect(cancelledAmount).to.be.bignumber.equal(cancelAmount);
                 });
             });
@@ -719,19 +739,19 @@ describe('ExchangeWrapper', () => {
                 const emptyCancelTakerTokenAmount = new BigNumber(0);
                 it('should validate when orderTransactionOptions are not present', async () => {
                     return expect(
-                        zeroEx.exchange.cancelOrderAsync(signedOrder, emptyCancelTakerTokenAmount),
+                        contractWrappers.exchange.cancelOrderAsync(signedOrder, emptyCancelTakerTokenAmount),
                     ).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
                 });
                 it('should validate when orderTransactionOptions specify to validate', async () => {
                     return expect(
-                        zeroEx.exchange.cancelOrderAsync(signedOrder, emptyCancelTakerTokenAmount, {
+                        contractWrappers.exchange.cancelOrderAsync(signedOrder, emptyCancelTakerTokenAmount, {
                             shouldValidate: true,
                         }),
                     ).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
                 });
                 it('should not validate when orderTransactionOptions specify not to validate', async () => {
                     return expect(
-                        zeroEx.exchange.cancelOrderAsync(signedOrder, emptyCancelTakerTokenAmount, {
+                        contractWrappers.exchange.cancelOrderAsync(signedOrder, emptyCancelTakerTokenAmount, {
                             shouldValidate: false,
                         }),
                     ).to.not.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
@@ -750,7 +770,7 @@ describe('ExchangeWrapper', () => {
                     takerAddress,
                     fillableAmount,
                 );
-                anotherOrderHashHex = ZeroEx.getOrderHashHex(anotherSignedOrder);
+                anotherOrderHashHex = getOrderHashHex(anotherSignedOrder);
                 cancelBatch = [
                     {
                         order: signedOrder,
@@ -772,7 +792,7 @@ describe('ExchangeWrapper', () => {
                         fillableAmount,
                     );
                     return expect(
-                        zeroEx.exchange.batchCancelOrdersAsync([
+                        contractWrappers.exchange.batchCancelOrdersAsync([
                             cancelBatch[0],
                             {
                                 order: signedOrderWithDifferentMaker,
@@ -784,9 +804,9 @@ describe('ExchangeWrapper', () => {
             });
             describe('successful batch cancels', () => {
                 it('should cancel a batch of orders', async () => {
-                    await zeroEx.exchange.batchCancelOrdersAsync(cancelBatch);
-                    const cancelledAmount = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHashHex);
-                    const anotherCancelledAmount = await zeroEx.exchange.getCancelledTakerAmountAsync(
+                    await contractWrappers.exchange.batchCancelOrdersAsync(cancelBatch);
+                    const cancelledAmount = await contractWrappers.exchange.getCancelledTakerAmountAsync(orderHashHex);
+                    const anotherCancelledAmount = await contractWrappers.exchange.getCancelledTakerAmountAsync(
                         anotherOrderHashHex,
                     );
                     expect(cancelledAmount).to.be.bignumber.equal(cancelAmount);
@@ -808,20 +828,20 @@ describe('ExchangeWrapper', () => {
                     ];
                 });
                 it('should validate when orderTransactionOptions are not present', async () => {
-                    return expect(zeroEx.exchange.batchCancelOrdersAsync(cancelBatch)).to.be.rejectedWith(
+                    return expect(contractWrappers.exchange.batchCancelOrdersAsync(cancelBatch)).to.be.rejectedWith(
                         ExchangeContractErrs.OrderCancelAmountZero,
                     );
                 });
                 it('should validate when orderTransactionOptions specify to validate', async () => {
                     return expect(
-                        zeroEx.exchange.batchCancelOrdersAsync(cancelBatch, {
+                        contractWrappers.exchange.batchCancelOrdersAsync(cancelBatch, {
                             shouldValidate: true,
                         }),
                     ).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
                 });
                 it('should not validate when orderTransactionOptions specify not to validate', async () => {
                     return expect(
-                        zeroEx.exchange.batchCancelOrdersAsync(cancelBatch, {
+                        contractWrappers.exchange.batchCancelOrdersAsync(cancelBatch, {
                             shouldValidate: false,
                         }),
                     ).to.not.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
@@ -854,53 +874,63 @@ describe('ExchangeWrapper', () => {
                 fillableAmount,
                 partialFillAmount,
             );
-            orderHash = ZeroEx.getOrderHashHex(signedOrder);
+            orderHash = getOrderHashHex(signedOrder);
         });
         describe('#getUnavailableTakerAmountAsync', () => {
             it('should throw if passed an invalid orderHash', async () => {
                 const invalidOrderHashHex = '0x123';
-                return expect(zeroEx.exchange.getUnavailableTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
+                return expect(
+                    contractWrappers.exchange.getUnavailableTakerAmountAsync(invalidOrderHashHex),
+                ).to.be.rejected();
             });
             it('should return zero if passed a valid but non-existent orderHash', async () => {
-                const unavailableValueT = await zeroEx.exchange.getUnavailableTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
+                const unavailableValueT = await contractWrappers.exchange.getUnavailableTakerAmountAsync(
+                    NON_EXISTENT_ORDER_HASH,
+                );
                 expect(unavailableValueT).to.be.bignumber.equal(0);
             });
             it('should return the unavailableValueT for a valid and partially filled orderHash', async () => {
-                const unavailableValueT = await zeroEx.exchange.getUnavailableTakerAmountAsync(orderHash);
+                const unavailableValueT = await contractWrappers.exchange.getUnavailableTakerAmountAsync(orderHash);
                 expect(unavailableValueT).to.be.bignumber.equal(partialFillAmount);
             });
         });
         describe('#getFilledTakerAmountAsync', () => {
             it('should throw if passed an invalid orderHash', async () => {
                 const invalidOrderHashHex = '0x123';
-                return expect(zeroEx.exchange.getFilledTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
+                return expect(
+                    contractWrappers.exchange.getFilledTakerAmountAsync(invalidOrderHashHex),
+                ).to.be.rejected();
             });
             it('should return zero if passed a valid but non-existent orderHash', async () => {
-                const filledValueT = await zeroEx.exchange.getFilledTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
+                const filledValueT = await contractWrappers.exchange.getFilledTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
                 expect(filledValueT).to.be.bignumber.equal(0);
             });
             it('should return the filledValueT for a valid and partially filled orderHash', async () => {
-                const filledValueT = await zeroEx.exchange.getFilledTakerAmountAsync(orderHash);
+                const filledValueT = await contractWrappers.exchange.getFilledTakerAmountAsync(orderHash);
                 expect(filledValueT).to.be.bignumber.equal(partialFillAmount);
             });
         });
         describe('#getCancelledTakerAmountAsync', () => {
             it('should throw if passed an invalid orderHash', async () => {
                 const invalidOrderHashHex = '0x123';
-                return expect(zeroEx.exchange.getCancelledTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
+                return expect(
+                    contractWrappers.exchange.getCancelledTakerAmountAsync(invalidOrderHashHex),
+                ).to.be.rejected();
             });
             it('should return zero if passed a valid but non-existent orderHash', async () => {
-                const cancelledValueT = await zeroEx.exchange.getCancelledTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
+                const cancelledValueT = await contractWrappers.exchange.getCancelledTakerAmountAsync(
+                    NON_EXISTENT_ORDER_HASH,
+                );
                 expect(cancelledValueT).to.be.bignumber.equal(0);
             });
             it('should return the cancelledValueT for a valid and partially filled orderHash', async () => {
-                const cancelledValueT = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHash);
+                const cancelledValueT = await contractWrappers.exchange.getCancelledTakerAmountAsync(orderHash);
                 expect(cancelledValueT).to.be.bignumber.equal(0);
             });
             it('should return the cancelledValueT for a valid and cancelled orderHash', async () => {
                 const cancelAmount = fillableAmount.minus(partialFillAmount);
-                await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmount);
-                const cancelledValueT = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHash);
+                await contractWrappers.exchange.cancelOrderAsync(signedOrder, cancelAmount);
+                const cancelledValueT = await contractWrappers.exchange.getCancelledTakerAmountAsync(orderHash);
                 expect(cancelledValueT).to.be.bignumber.equal(cancelAmount);
             });
         });
@@ -934,7 +964,7 @@ describe('ExchangeWrapper', () => {
             );
         });
         afterEach(async () => {
-            zeroEx.exchange.unsubscribeAll();
+            contractWrappers.exchange.unsubscribeAll();
         });
         // Hack: Mocha does not allow a test to be both async and have a `done` callback
         // Since we need to await the receipt of the event in the `subscribe` callback,
@@ -943,13 +973,13 @@ describe('ExchangeWrapper', () => {
         // Source: https://github.com/mochajs/mocha/issues/2407
         it('Should receive the LogFill event when an order is filled', (done: DoneCallback) => {
             (async () => {
-                const callback = reportNodeCallbackErrors(done)(
+                const callback = callbackErrorReporter.reportNodeCallbackErrors(done)(
                     (logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
                         expect(logEvent.log.event).to.be.equal(ExchangeEvents.LogFill);
                     },
                 );
-                zeroEx.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callback);
-                await zeroEx.exchange.fillOrderAsync(
+                contractWrappers.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callback);
+                await contractWrappers.exchange.fillOrderAsync(
                     signedOrder,
                     takerTokenFillAmountInBaseUnits,
                     shouldThrowOnInsufficientBalanceOrAllowance,
@@ -959,33 +989,33 @@ describe('ExchangeWrapper', () => {
         });
         it('Should receive the LogCancel event when an order is cancelled', (done: DoneCallback) => {
             (async () => {
-                const callback = reportNodeCallbackErrors(done)(
+                const callback = callbackErrorReporter.reportNodeCallbackErrors(done)(
                     (logEvent: DecodedLogEvent<LogCancelContractEventArgs>) => {
                         expect(logEvent.log.event).to.be.equal(ExchangeEvents.LogCancel);
                     },
                 );
-                zeroEx.exchange.subscribe(ExchangeEvents.LogCancel, indexFilterValues, callback);
-                await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelTakerAmountInBaseUnits);
+                contractWrappers.exchange.subscribe(ExchangeEvents.LogCancel, indexFilterValues, callback);
+                await contractWrappers.exchange.cancelOrderAsync(signedOrder, cancelTakerAmountInBaseUnits);
             })().catch(done);
         });
-        it('Outstanding subscriptions are cancelled when zeroEx.setProvider called', (done: DoneCallback) => {
+        it('Outstanding subscriptions are cancelled when contractWrappers.setProvider called', (done: DoneCallback) => {
             (async () => {
-                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
+                const callbackNeverToBeCalled = callbackErrorReporter.reportNodeCallbackErrors(done)(
                     (logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
                         done(new Error('Expected this subscription to have been cancelled'));
                     },
                 );
-                zeroEx.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callbackNeverToBeCalled);
+                contractWrappers.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callbackNeverToBeCalled);
 
-                zeroEx.setProvider(provider, constants.TESTRPC_NETWORK_ID);
+                contractWrappers.setProvider(provider, constants.TESTRPC_NETWORK_ID);
 
-                const callback = reportNodeCallbackErrors(done)(
+                const callback = callbackErrorReporter.reportNodeCallbackErrors(done)(
                     (logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
                         expect(logEvent.log.event).to.be.equal(ExchangeEvents.LogFill);
                     },
                 );
-                zeroEx.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callback);
-                await zeroEx.exchange.fillOrderAsync(
+                contractWrappers.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callback);
+                await contractWrappers.exchange.fillOrderAsync(
                     signedOrder,
                     takerTokenFillAmountInBaseUnits,
                     shouldThrowOnInsufficientBalanceOrAllowance,
@@ -995,18 +1025,18 @@ describe('ExchangeWrapper', () => {
         });
         it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
             (async () => {
-                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
+                const callbackNeverToBeCalled = callbackErrorReporter.reportNodeCallbackErrors(done)(
                     (logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
                         done(new Error('Expected this subscription to have been cancelled'));
                     },
                 );
-                const subscriptionToken = zeroEx.exchange.subscribe(
+                const subscriptionToken = contractWrappers.exchange.subscribe(
                     ExchangeEvents.LogFill,
                     indexFilterValues,
                     callbackNeverToBeCalled,
                 );
-                zeroEx.exchange.unsubscribe(subscriptionToken);
-                await zeroEx.exchange.fillOrderAsync(
+                contractWrappers.exchange.unsubscribe(subscriptionToken);
+                await contractWrappers.exchange.fillOrderAsync(
                     signedOrder,
                     takerTokenFillAmountInBaseUnits,
                     shouldThrowOnInsufficientBalanceOrAllowance,
@@ -1036,8 +1066,8 @@ describe('ExchangeWrapper', () => {
                 takerAddress,
                 fillableAmount,
             );
-            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-            const orderHashFromContract = await (zeroEx.exchange as any)._getOrderHashHexUsingContractCallAsync(
+            const orderHash = getOrderHashHex(signedOrder);
+            const orderHashFromContract = await (contractWrappers.exchange as any)._getOrderHashHexUsingContractCallAsync(
                 signedOrder,
             );
             expect(orderHash).to.equal(orderHashFromContract);
@@ -1045,7 +1075,7 @@ describe('ExchangeWrapper', () => {
     });
     describe('#getZRXTokenAddressAsync', () => {
         it('gets the same token as is in token registry', () => {
-            const zrxAddress = zeroEx.exchange.getZRXTokenAddress();
+            const zrxAddress = contractWrappers.exchange.getZRXTokenAddress();
             const zrxToken = tokenUtils.getProtocolTokenOrThrow();
             expect(zrxAddress).to.equal(zrxToken.address);
         });
@@ -1076,16 +1106,16 @@ describe('ExchangeWrapper', () => {
                 takerAddress,
                 fillableAmount,
             );
-            txHash = await zeroEx.exchange.fillOrderAsync(
+            txHash = await contractWrappers.exchange.fillOrderAsync(
                 signedOrder,
                 fillableAmount,
                 shouldThrowOnInsufficientBalanceOrAllowance,
                 takerAddress,
             );
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
             const eventName = ExchangeEvents.LogFill;
             const indexFilterValues = {};
-            const logs = await zeroEx.exchange.getLogsAsync(eventName, blockRange, indexFilterValues);
+            const logs = await contractWrappers.exchange.getLogsAsync(eventName, blockRange, indexFilterValues);
             expect(logs).to.have.length(1);
             expect(logs[0].event).to.be.equal(eventName);
         });
@@ -1097,16 +1127,20 @@ describe('ExchangeWrapper', () => {
                 takerAddress,
                 fillableAmount,
             );
-            txHash = await zeroEx.exchange.fillOrderAsync(
+            txHash = await contractWrappers.exchange.fillOrderAsync(
                 signedOrder,
                 fillableAmount,
                 shouldThrowOnInsufficientBalanceOrAllowance,
                 takerAddress,
             );
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
             const differentEventName = ExchangeEvents.LogCancel;
             const indexFilterValues = {};
-            const logs = await zeroEx.exchange.getLogsAsync(differentEventName, blockRange, indexFilterValues);
+            const logs = await contractWrappers.exchange.getLogsAsync(
+                differentEventName,
+                blockRange,
+                indexFilterValues,
+            );
             expect(logs).to.have.length(0);
         });
         it('should only get the logs with the correct indexed fields', async () => {
@@ -1117,13 +1151,13 @@ describe('ExchangeWrapper', () => {
                 takerAddress,
                 fillableAmount,
             );
-            txHash = await zeroEx.exchange.fillOrderAsync(
+            txHash = await contractWrappers.exchange.fillOrderAsync(
                 signedOrder,
                 fillableAmount,
                 shouldThrowOnInsufficientBalanceOrAllowance,
                 takerAddress,
             );
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
 
             const differentMakerAddress = userAddresses[2];
             const anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
@@ -1133,19 +1167,19 @@ describe('ExchangeWrapper', () => {
                 takerAddress,
                 fillableAmount,
             );
-            txHash = await zeroEx.exchange.fillOrderAsync(
+            txHash = await contractWrappers.exchange.fillOrderAsync(
                 anotherSignedOrder,
                 fillableAmount,
                 shouldThrowOnInsufficientBalanceOrAllowance,
                 takerAddress,
             );
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            await web3Wrapper.awaitTransactionMinedAsync(txHash);
 
             const eventName = ExchangeEvents.LogFill;
             const indexFilterValues = {
                 maker: differentMakerAddress,
             };
-            const logs = await zeroEx.exchange.getLogsAsync<LogFillContractEventArgs>(
+            const logs = await contractWrappers.exchange.getLogsAsync<LogFillContractEventArgs>(
                 eventName,
                 blockRange,
                 indexFilterValues,
@@ -1162,10 +1196,10 @@ describe('ExchangeWrapper', () => {
         let takerToken: Token;
         let signedOrder: SignedOrder;
         let orderState: OrderState;
-        const fillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(5), constants.ZRX_DECIMALS);
+        const fillableAmount = Web3Wrapper.toBaseUnitAmount(new BigNumber(5), constants.ZRX_DECIMALS);
         before(async () => {
             [, maker, taker] = userAddresses;
-            tokens = await zeroEx.tokenRegistry.getTokensAsync();
+            tokens = await contractWrappers.tokenRegistry.getTokensAsync();
             [makerToken, takerToken] = tokenUtils.getDummyTokens();
         });
         it('should report orderStateValid when order is fillable', async () => {
@@ -1176,7 +1210,7 @@ describe('ExchangeWrapper', () => {
                 taker,
                 fillableAmount,
             );
-            orderState = await zeroEx.exchange.getOrderStateAsync(signedOrder);
+            orderState = await contractWrappers.exchange.getOrderStateAsync(signedOrder);
             expect(orderState.isValid).to.be.true();
         });
         it('should report orderStateInvalid when maker allowance set to 0', async () => {
@@ -1187,8 +1221,8 @@ describe('ExchangeWrapper', () => {
                 taker,
                 fillableAmount,
             );
-            await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, new BigNumber(0));
-            orderState = await zeroEx.exchange.getOrderStateAsync(signedOrder);
+            await contractWrappers.token.setProxyAllowanceAsync(makerToken.address, maker, new BigNumber(0));
+            orderState = await contractWrappers.exchange.getOrderStateAsync(signedOrder);
             expect(orderState.isValid).to.be.false();
         });
     });

packages/contract-wrappers/test/global_hooks.ts

@@ -0,0 +1,19 @@
+import { devConstants } from '@0xproject/dev-utils';
+import { runMigrationsAsync } from '@0xproject/migrations';
+import * as path from 'path';
+
+import { constants } from './utils/constants';
+import { provider } from './utils/web3_wrapper';
+
+before('migrate contracts', async function(): Promise<void> {
+    // HACK: Since the migrations take longer then our global mocha timeout limit
+    // we manually increase it for this before hook.
+    const mochaTestTimeoutMs = 20000;
+    this.timeout(mochaTestTimeoutMs);
+    const txDefaults = {
+        gas: devConstants.GAS_ESTIMATE,
+        from: devConstants.TESTRPC_FIRST_ADDRESS,
+    };
+    const artifactsDir = `../migrations/artifacts/1.0.0`;
+    await runMigrationsAsync(provider, artifactsDir, txDefaults);
+});

packages/contract-wrappers/test/order_validation_test.ts

@@ -1,17 +1,19 @@
 import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
+import { FillScenarios } from '@0xproject/fill-scenarios';
+import { OrderError } from '@0xproject/order-utils';
 import { BlockParamLiteral } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
+import 'make-promises-safe';
 import * as Sinon from 'sinon';
 
-import { ExchangeContractErrs, SignedOrder, Token, ZeroEx, ZeroExError } from '../src';
+import { ContractWrappers, ContractWrappersError, ExchangeContractErrs, SignedOrder, Token } from '../src';
 import { TradeSide, TransferType } from '../src/types';
 import { ExchangeTransferSimulator } from '../src/utils/exchange_transfer_simulator';
 import { OrderValidationUtils } from '../src/utils/order_validation_utils';
 
 import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
-import { FillScenarios } from './utils/fill_scenarios';
 import { TokenUtils } from './utils/token_utils';
 import { provider, web3Wrapper } from './utils/web3_wrapper';
 
@@ -20,7 +22,7 @@ const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 describe('OrderValidation', () => {
-    let zeroEx: ZeroEx;
+    let contractWrappers: ContractWrappers;
     let userAddresses: string[];
     let tokens: Token[];
     let tokenUtils: TokenUtils;
@@ -39,14 +41,14 @@ describe('OrderValidation', () => {
         networkId: constants.TESTRPC_NETWORK_ID,
     };
     before(async () => {
-        zeroEx = new ZeroEx(provider, config);
-        exchangeContractAddress = zeroEx.exchange.getContractAddress();
-        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        contractWrappers = new ContractWrappers(provider, config);
+        exchangeContractAddress = contractWrappers.exchange.getContractAddress();
+        userAddresses = await web3Wrapper.getAvailableAddressesAsync();
         [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        tokens = await contractWrappers.tokenRegistry.getTokensAsync();
         tokenUtils = new TokenUtils(tokens);
         zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
-        fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
+        fillScenarios = new FillScenarios(provider, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
         const [makerToken, takerToken] = tokenUtils.getDummyTokens();
         makerTokenAddress = makerToken.address;
         takerTokenAddress = takerToken.address;
@@ -66,10 +68,45 @@ describe('OrderValidation', () => {
                 takerAddress,
                 fillableAmount,
             );
-            await zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder);
+            await contractWrappers.exchange.validateOrderFillableOrThrowAsync(signedOrder);
+        });
+        it('should succeed if the maker is buying ZRX and has no ZRX balance', async () => {
+            const makerFee = new BigNumber(2);
+            const takerFee = new BigNumber(2);
+            const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                makerTokenAddress,
+                zrxTokenAddress,
+                makerFee,
+                takerFee,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+                feeRecipient,
+            );
+            const zrxMakerBalance = await contractWrappers.token.getBalanceAsync(zrxTokenAddress, makerAddress);
+            await contractWrappers.token.transferAsync(zrxTokenAddress, makerAddress, takerAddress, zrxMakerBalance);
+            await contractWrappers.exchange.validateOrderFillableOrThrowAsync(signedOrder);
+        });
+        it('should succeed if the maker is buying ZRX and has no ZRX balance and there is no specified taker', async () => {
+            const makerFee = new BigNumber(2);
+            const takerFee = new BigNumber(2);
+            const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                makerTokenAddress,
+                zrxTokenAddress,
+                makerFee,
+                takerFee,
+                makerAddress,
+                constants.NULL_ADDRESS,
+                fillableAmount,
+                feeRecipient,
+            );
+            const zrxMakerBalance = await contractWrappers.token.getBalanceAsync(zrxTokenAddress, makerAddress);
+            await contractWrappers.token.transferAsync(zrxTokenAddress, makerAddress, takerAddress, zrxMakerBalance);
+            await contractWrappers.exchange.validateOrderFillableOrThrowAsync(signedOrder);
         });
         it('should succeed if the order is asymmetric and fillable', async () => {
             const makerFillableAmount = fillableAmount;
+            // tslint:disable-next-line:custom-no-magic-numbers
             const takerFillableAmount = fillableAmount.minus(4);
             const signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
                 makerTokenAddress,
@@ -79,7 +116,7 @@ describe('OrderValidation', () => {
                 makerFillableAmount,
                 takerFillableAmount,
             );
-            await zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder);
+            await contractWrappers.exchange.validateOrderFillableOrThrowAsync(signedOrder);
         });
         it('should throw when the order is fully filled or cancelled', async () => {
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
@@ -89,8 +126,8 @@ describe('OrderValidation', () => {
                 takerAddress,
                 fillableAmount,
             );
-            await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
-            return expect(zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder)).to.be.rejectedWith(
+            await contractWrappers.exchange.cancelOrderAsync(signedOrder, fillableAmount);
+            return expect(contractWrappers.exchange.validateOrderFillableOrThrowAsync(signedOrder)).to.be.rejectedWith(
                 ExchangeContractErrs.OrderRemainingFillAmountZero,
             );
         });
@@ -104,7 +141,7 @@ describe('OrderValidation', () => {
                 fillableAmount,
                 expirationInPast,
             );
-            return expect(zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder)).to.be.rejectedWith(
+            return expect(contractWrappers.exchange.validateOrderFillableOrThrowAsync(signedOrder)).to.be.rejectedWith(
                 ExchangeContractErrs.OrderFillExpired,
             );
         });
@@ -120,7 +157,11 @@ describe('OrderValidation', () => {
             );
             const zeroFillAmount = new BigNumber(0);
             return expect(
-                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, zeroFillAmount, takerAddress),
+                contractWrappers.exchange.validateFillOrderThrowIfInvalidAsync(
+                    signedOrder,
+                    zeroFillAmount,
+                    takerAddress,
+                ),
             ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
         });
         it('should throw when the signature is invalid', async () => {
@@ -132,10 +173,15 @@ describe('OrderValidation', () => {
                 fillableAmount,
             );
             // 27 <--> 28
+            // tslint:disable-next-line:custom-no-magic-numbers
             signedOrder.ecSignature.v = 28 - signedOrder.ecSignature.v + 27;
             return expect(
-                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillableAmount, takerAddress),
-            ).to.be.rejectedWith(ZeroExError.InvalidSignature);
+                contractWrappers.exchange.validateFillOrderThrowIfInvalidAsync(
+                    signedOrder,
+                    fillableAmount,
+                    takerAddress,
+                ),
+            ).to.be.rejectedWith(OrderError.InvalidSignature);
         });
         it('should throw when the order is fully filled or cancelled', async () => {
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
@@ -145,9 +191,13 @@ describe('OrderValidation', () => {
                 takerAddress,
                 fillableAmount,
             );
-            await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
+            await contractWrappers.exchange.cancelOrderAsync(signedOrder, fillableAmount);
             return expect(
-                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillableAmount, takerAddress),
+                contractWrappers.exchange.validateFillOrderThrowIfInvalidAsync(
+                    signedOrder,
+                    fillableAmount,
+                    takerAddress,
+                ),
             ).to.be.rejectedWith(ExchangeContractErrs.OrderRemainingFillAmountZero);
         });
         it('should throw when sender is not a taker', async () => {
@@ -158,9 +208,14 @@ describe('OrderValidation', () => {
                 takerAddress,
                 fillableAmount,
             );
+            // tslint:disable-next-line:custom-no-magic-numbers
             const nonTakerAddress = userAddresses[6];
             return expect(
-                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillTakerAmount, nonTakerAddress),
+                contractWrappers.exchange.validateFillOrderThrowIfInvalidAsync(
+                    signedOrder,
+                    fillTakerAmount,
+                    nonTakerAddress,
+                ),
             ).to.be.rejectedWith(ExchangeContractErrs.TransactionSenderIsNotFillOrderTaker);
         });
         it('should throw when order is expired', async () => {
@@ -174,7 +229,11 @@ describe('OrderValidation', () => {
                 expirationInPast,
             );
             return expect(
-                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillTakerAmount, takerAddress),
+                contractWrappers.exchange.validateFillOrderThrowIfInvalidAsync(
+                    signedOrder,
+                    fillTakerAmount,
+                    takerAddress,
+                ),
             ).to.be.rejectedWith(ExchangeContractErrs.OrderFillExpired);
         });
         it('should throw when there a rounding error would have occurred', async () => {
@@ -190,7 +249,7 @@ describe('OrderValidation', () => {
             );
             const fillTakerAmountThatCausesRoundingError = new BigNumber(3);
             return expect(
-                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(
+                contractWrappers.exchange.validateFillOrderThrowIfInvalidAsync(
                     signedOrder,
                     fillTakerAmountThatCausesRoundingError,
                     takerAddress,
@@ -209,13 +268,13 @@ describe('OrderValidation', () => {
             );
             const tooLargeFillAmount = new BigNumber(7);
             const fillAmountDifference = tooLargeFillAmount.minus(fillableAmount);
-            await zeroEx.token.transferAsync(takerTokenAddress, coinbase, takerAddress, fillAmountDifference);
-            await zeroEx.token.setProxyAllowanceAsync(takerTokenAddress, takerAddress, tooLargeFillAmount);
-            await zeroEx.token.transferAsync(makerTokenAddress, coinbase, makerAddress, fillAmountDifference);
-            await zeroEx.token.setProxyAllowanceAsync(makerTokenAddress, makerAddress, tooLargeFillAmount);
+            await contractWrappers.token.transferAsync(takerTokenAddress, coinbase, takerAddress, fillAmountDifference);
+            await contractWrappers.token.setProxyAllowanceAsync(takerTokenAddress, takerAddress, tooLargeFillAmount);
+            await contractWrappers.token.transferAsync(makerTokenAddress, coinbase, makerAddress, fillAmountDifference);
+            await contractWrappers.token.setProxyAllowanceAsync(makerTokenAddress, makerAddress, tooLargeFillAmount);
 
             return expect(
-                zeroEx.exchange.validateFillOrKillOrderThrowIfInvalidAsync(
+                contractWrappers.exchange.validateFillOrKillOrderThrowIfInvalidAsync(
                     signedOrder,
                     tooLargeFillAmount,
                     takerAddress,
@@ -242,7 +301,7 @@ describe('OrderValidation', () => {
         it('should throw when cancel amount is zero', async () => {
             const zeroCancelAmount = new BigNumber(0);
             return expect(
-                zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(signedOrder, zeroCancelAmount),
+                contractWrappers.exchange.validateCancelOrderThrowIfInvalidAsync(signedOrder, zeroCancelAmount),
             ).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
         });
         it('should throw when order is expired', async () => {
@@ -256,13 +315,13 @@ describe('OrderValidation', () => {
                 expirationInPast,
             );
             return expect(
-                zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(expiredSignedOrder, cancelAmount),
+                contractWrappers.exchange.validateCancelOrderThrowIfInvalidAsync(expiredSignedOrder, cancelAmount),
             ).to.be.rejectedWith(ExchangeContractErrs.OrderCancelExpired);
         });
         it('should throw when order is already cancelled or filled', async () => {
-            await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
+            await contractWrappers.exchange.cancelOrderAsync(signedOrder, fillableAmount);
             return expect(
-                zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(signedOrder, fillableAmount),
+                contractWrappers.exchange.validateCancelOrderThrowIfInvalidAsync(signedOrder, fillableAmount),
             ).to.be.rejectedWith(ExchangeContractErrs.OrderAlreadyCancelledOrFilled);
         });
     });
@@ -273,7 +332,7 @@ describe('OrderValidation', () => {
             return Sinon.match((value: BigNumber) => value.eq(expected));
         };
         beforeEach('create exchangeTransferSimulator', async () => {
-            exchangeTransferSimulator = new ExchangeTransferSimulator(zeroEx.token, BlockParamLiteral.Latest);
+            exchangeTransferSimulator = new ExchangeTransferSimulator(contractWrappers.token, BlockParamLiteral.Latest);
             transferFromAsync = Sinon.spy();
             exchangeTransferSimulator.transferFromAsync = transferFromAsync as any;
         });
@@ -297,6 +356,7 @@ describe('OrderValidation', () => {
                 takerAddress,
                 zrxTokenAddress,
             );
+            // tslint:disable-next-line:custom-no-magic-numbers
             expect(transferFromAsync.callCount).to.be.equal(4);
             expect(
                 transferFromAsync
@@ -356,7 +416,7 @@ describe('OrderValidation', () => {
                 makerFee,
                 takerFee,
                 makerAddress,
-                ZeroEx.NULL_ADDRESS,
+                constants.NULL_ADDRESS,
                 fillableAmount,
                 feeRecipient,
             );
@@ -367,6 +427,7 @@ describe('OrderValidation', () => {
                 takerAddress,
                 zrxTokenAddress,
             );
+            // tslint:disable-next-line:custom-no-magic-numbers
             expect(transferFromAsync.callCount).to.be.equal(4);
             expect(
                 transferFromAsync
@@ -435,6 +496,7 @@ describe('OrderValidation', () => {
                 takerAddress,
                 zrxTokenAddress,
             );
+            // tslint:disable-next-line:custom-no-magic-numbers
             expect(transferFromAsync.callCount).to.be.equal(4);
             const makerFillAmount = transferFromAsync.getCall(0).args[3];
             expect(makerFillAmount).to.be.bignumber.equal(makerTokenAmount);
@@ -450,7 +512,7 @@ describe('OrderValidation', () => {
                 makerAddress,
                 takerAddress,
                 fillableAmount,
-                ZeroEx.NULL_ADDRESS,
+                constants.NULL_ADDRESS,
             );
             const fillTakerTokenAmount = fillableAmount.div(2).round(0);
             await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
@@ -462,6 +524,7 @@ describe('OrderValidation', () => {
             );
             const makerPartialFee = makerFee.div(2);
             const takerPartialFee = takerFee.div(2);
+            // tslint:disable-next-line:custom-no-magic-numbers
             expect(transferFromAsync.callCount).to.be.equal(4);
             const partialMakerFee = transferFromAsync.getCall(2).args[3];
             expect(partialMakerFee).to.be.bignumber.equal(makerPartialFee);
@@ -469,4 +532,4 @@ describe('OrderValidation', () => {
             expect(partialTakerFee).to.be.bignumber.equal(takerPartialFee);
         });
     });
-});
+}); // tslint:disable-line:max-file-line-count

packages/contract-wrappers/test/subscription_test.ts

@@ -1,22 +1,22 @@
-import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
+import { BlockchainLifecycle, callbackErrorReporter, devConstants } from '@0xproject/dev-utils';
+import { DoneCallback } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
+import 'make-promises-safe';
 import 'mocha';
 import * as Sinon from 'sinon';
 
-import { ApprovalContractEventArgs, DecodedLogEvent, Token, TokenEvents, ZeroEx } from '../src';
-import { DoneCallback } from '../src/types';
+import { ApprovalContractEventArgs, ContractWrappers, DecodedLogEvent, Token, TokenEvents } from '../src';
 
 import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
-import { assertNodeCallbackError } from './utils/report_callback_errors';
 import { provider, web3Wrapper } from './utils/web3_wrapper';
 
 chaiSetup.configure();
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 describe('SubscriptionTest', () => {
-    let zeroEx: ZeroEx;
+    let contractWrappers: ContractWrappers;
     let userAddresses: string[];
     let tokens: Token[];
     let coinbase: string;
@@ -25,9 +25,9 @@ describe('SubscriptionTest', () => {
         networkId: constants.TESTRPC_NETWORK_ID,
     };
     before(async () => {
-        zeroEx = new ZeroEx(provider, config);
-        userAddresses = await zeroEx.getAvailableAddressesAsync();
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        contractWrappers = new ContractWrappers(provider, config);
+        userAddresses = await web3Wrapper.getAvailableAddressesAsync();
+        tokens = await contractWrappers.tokenRegistry.getTokensAsync();
         coinbase = userAddresses[0];
         addressWithoutFunds = userAddresses[1];
     });
@@ -47,34 +47,48 @@ describe('SubscriptionTest', () => {
             tokenAddress = token.address;
         });
         afterEach(() => {
-            zeroEx.token.unsubscribeAll();
+            contractWrappers.token.unsubscribeAll();
             _.each(stubs, s => s.restore());
             stubs = [];
         });
         it('Should receive the Error when an error occurs while fetching the block', (done: DoneCallback) => {
             (async () => {
                 const errMsg = 'Error fetching block';
-                const callback = assertNodeCallbackError(done, errMsg);
-                stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync').throws(new Error(errMsg))];
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
-                await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
+                const callback = callbackErrorReporter.assertNodeCallbackError(done, errMsg);
+                stubs = [Sinon.stub((contractWrappers as any)._web3Wrapper, 'getBlockAsync').throws(new Error(errMsg))];
+                contractWrappers.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
+                await contractWrappers.token.setAllowanceAsync(
+                    tokenAddress,
+                    coinbase,
+                    addressWithoutFunds,
+                    allowanceAmount,
+                );
             })().catch(done);
         });
         it('Should receive the Error when an error occurs while reconciling the new block', (done: DoneCallback) => {
             (async () => {
                 const errMsg = 'Error fetching logs';
-                const callback = assertNodeCallbackError(done, errMsg);
-                stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getLogsAsync').throws(new Error(errMsg))];
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
-                await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
+                const callback = callbackErrorReporter.assertNodeCallbackError(done, errMsg);
+                stubs = [Sinon.stub((contractWrappers as any)._web3Wrapper, 'getLogsAsync').throws(new Error(errMsg))];
+                contractWrappers.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
+                await contractWrappers.token.setAllowanceAsync(
+                    tokenAddress,
+                    coinbase,
+                    addressWithoutFunds,
+                    allowanceAmount,
+                );
             })().catch(done);
         });
         it('Should allow unsubscribeAll to be called successfully after an error', (done: DoneCallback) => {
             (async () => {
                 const callback = (err: Error | null, logEvent?: DecodedLogEvent<ApprovalContractEventArgs>) => _.noop;
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
-                stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync').throws(new Error('JSON RPC error'))];
-                zeroEx.token.unsubscribeAll();
+                contractWrappers.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
+                stubs = [
+                    Sinon.stub((contractWrappers as any)._web3Wrapper, 'getBlockAsync').throws(
+                        new Error('JSON RPC error'),
+                    ),
+                ];
+                contractWrappers.token.unsubscribeAll();
                 done();
             })().catch(done);
         });