Publish

- 0x.js@0.26.1
 - @0xproject/connect@0.1.0

.circleci/config.yml

@@ -5,208 +5,24 @@ jobs:
     docker:
       - image: circleci/node:6.12
     environment:
-      CONTRACTS_COMMIT_HASH: '9ed05f5'
-    working_directory: ~/repo
+      CONTRACTS_COMMIT_HASH: '78fe8dd'
     steps:
       - checkout
       - run: echo 'export PATH=$HOME/CIRCLE_PROJECT_REPONAME/node_modules/.bin:$PATH' >> $BASH_ENV
-      - restore_cache:
-          key: dependency-cache-{{ checksum "package.json" }}
       - run:
           name: yarn
-          command: yarn --frozen-lockfile
+          command: yarn
       - save_cache:
           key: dependency-cache-{{ checksum "package.json" }}
           paths:
-            - ./node_modules
+            - ~/.cache/yarn
       - 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
-      - save_cache:
-          key: repo-{{ .Environment.CIRCLE_SHA1 }}
-          paths:
-            - ~/repo
-  test-installation:
-    docker:
-      - image: circleci/node:6.12
-    working_directory: ~/repo
-    steps:
-      - restore_cache:
-          keys:
-            - repo-{{ .Environment.CIRCLE_SHA1 }}
-      - run: yarn test:installation
-  test-0xjs:
-    docker:
-      - image: circleci/node:6.12
-    working_directory: ~/repo
-    steps:
-      - restore_cache:
-          keys:
-            - repo-{{ .Environment.CIRCLE_SHA1 }}
+      - run: yarn lerna:run bootstrap
       - run:
           name: testrpc
           command: npm run testrpc -- --db testrpc_snapshot
           background: true
-      - run: yarn lerna:run --scope 0x.js test:circleci
-      - save_cache:
-          key: coverage-0xjs-{{ .Environment.CIRCLE_SHA1 }}
-          paths:
-            - ~/repo/packages/0x.js/coverage/lcov.info
-  test-contracts:
-    docker:
-      - image: circleci/node:6.12
-    working_directory: ~/repo
-    steps:
-      - restore_cache:
-          keys:
-            - repo-{{ .Environment.CIRCLE_SHA1 }}
-      - run:
-          name: testrpc
-          command: npm run testrpc -- --db testrpc_snapshot
-          background: true
-      - run: yarn lerna:run --scope contracts test:circleci
-      - save_cache:
-          key: coverage-contracts-{{ .Environment.CIRCLE_SHA1 }}
-          paths:
-            - ~/repo/packages/contracts/coverage/lcov.info
-  test-deployer:
-    docker:
-      - image: circleci/node:6.12
-    working_directory: ~/repo
-    steps:
-      - restore_cache:
-          keys:
-            - repo-{{ .Environment.CIRCLE_SHA1 }}
-      - run:
-          name: testrpc
-          command: npm run testrpc -- --db testrpc_snapshot
-          background: true
-      - run: yarn lerna:run --scope @0xproject/deployer test:circleci
-      - save_cache:
-          key: coverage-deployer-{{ .Environment.CIRCLE_SHA1 }}
-          paths:
-            - ~/repo/packages/deployer/coverage/lcov.info
-  test-rest:
-    docker:
-      - image: circleci/node:6.12
-    working_directory: ~/repo
-    steps:
-      - restore_cache:
-          keys:
-            - repo-{{ .Environment.CIRCLE_SHA1 }}
-      - run:
-          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
-      - save_cache:
-          key: coverage-assert-{{ .Environment.CIRCLE_SHA1 }}
-          paths:
-            - ~/repo/packages/assert/coverage/lcov.info
-      - save_cache:
-          key: coverage-connect-{{ .Environment.CIRCLE_SHA1 }}
-          paths:
-            - ~/repo/packages/connect/coverage/lcov.info
-      - save_cache:
-          key: coverage-dev-utils-{{ .Environment.CIRCLE_SHA1 }}
-          paths:
-            - ~/repo/packages/dev-utils/coverage/lcov.info
-      - save_cache:
-          key: coverage-json-schemas-{{ .Environment.CIRCLE_SHA1 }}
-          paths:
-            - ~/repo/packages/json-schemas/coverage/lcov.info
-      - save_cache:
-          key: coverage-subproviders-{{ .Environment.CIRCLE_SHA1 }}
-          paths:
-            - ~/repo/packages/subproviders/coverage/lcov.info
-      - save_cache:
-          key: coverage-sol-cov-{{ .Environment.CIRCLE_SHA1 }}
-          paths:
-            - ~/repo/packages/sol-cov/coverage/lcov.info
-  lint:
-    working_directory: ~/repo
-    docker:
-      - image: circleci/node:6.12
-    steps:
-      - restore_cache:
-          keys:
-            - repo-{{ .Environment.CIRCLE_SHA1 }}
+      - run: yarn lerna:run test:circleci
       - run: yarn lerna:run lint
-  prettier:
-    working_directory: ~/repo
-    docker:
-      - image: circleci/node:6.12
-    steps:
-      - restore_cache:
-          keys:
-            - repo-{{ .Environment.CIRCLE_SHA1 }}
-      - run: yarn prettier:ci
-  submit-coverage:
-    docker:
-      - image: circleci/node:6.12
-    working_directory: ~/repo
-    steps:
-      - restore_cache:
-          keys:
-            - repo-{{ .Environment.CIRCLE_SHA1 }}
-      - restore_cache:
-          keys:
-            - coverage-contracts-{{ .Environment.CIRCLE_SHA1 }}
-      - restore_cache:
-          keys:
-            - coverage-assert-{{ .Environment.CIRCLE_SHA1 }}
-      - restore_cache:
-          keys:
-            - coverage-connect-{{ .Environment.CIRCLE_SHA1 }}
-      - restore_cache:
-          keys:
-            - coverage-dev-utils-{{ .Environment.CIRCLE_SHA1 }}
-      - restore_cache:
-          keys:
-            - coverage-json-schemas-{{ .Environment.CIRCLE_SHA1 }}
-      - restore_cache:
-          keys:
-            - coverage-subproviders-{{ .Environment.CIRCLE_SHA1 }}
-      - restore_cache:
-          keys:
-            - coverage-sol-cov-{{ .Environment.CIRCLE_SHA1 }}
-      - restore_cache:
-          keys:
-            - coverage-deployer-{{ .Environment.CIRCLE_SHA1 }}
-      - restore_cache:
-          keys:
-            - coverage-0xjs-{{ .Environment.CIRCLE_SHA1 }}
-      - run: yarn report_coverage
-workflows:
-  version: 2
-  main:
-    jobs:
-      - build
-      - test-installation:
-          requires:
-            - build
-      - test-0xjs:
-          requires:
-            - build
-      - test-contracts:
-          requires:
-            - build
-      - test-deployer:
-          requires:
-            - build
-      - test-rest:
-          requires:
-            - build
-      - prettier:
-          requires:
-            - build
-      - lint:
-          requires:
-            - build
-      - submit-coverage:
-          requires:
-            - test-0xjs
-            - test-deployer
-            - test-rest
-            - test-contracts

.editorconfig

@@ -1,12 +0,0 @@
-# EditorConfig  http://EditorConfig.org
-
-# top-most EditorConfig file
-root = true
-
-# All files
-[*]
-end_of_line = lf
-insert_final_newline = true
-charset = utf-8
-indent_style = space
-indent_size = 4

.gitattributes

@@ -1 +0,0 @@
-*.sol linguist-language=Solidity

.gitignore

@@ -63,26 +63,4 @@ lib/
 _bundles
 
 # generated documentation
-generated_docs/
-
-TODO.md
-
-packages/website/public/bundle*
-packages/react-docs/example/public/bundle*
-
-# generated binaries
-bin/
-
-# generated contract artifacts
-packages/contracts/src/artifacts
-
-# generated contract wrappers
-packages/0x.js/src/contract_wrappers/generated/
-packages/contracts/src/contract_wrappers/generated/
-packages/metacoin/src/contract_wrappers
-
-# solc-bin in deployer
-packages/deployer/solc_bin/
-
-# Monorepo scripts
-packages/*/scripts/
+docs/

.npmignore

@@ -0,0 +1,6 @@
+.*
+tsconfig.json
+tslint.json
+webpack.config.js
+yarn.lock
+docs

.prettierignore

@@ -1,5 +0,0 @@
-lib
-.nyc_output
-/packages/contracts/src/artifacts
-package.json
-scripts/postpublish_utils.js

.prettierrc

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

CODEOWNERS

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

CONTRIBUTING.md

@@ -1,46 +1,62 @@
-## 0x Contribution Guide
+# 0x.js CONTRIBUTING.md
 
-Thank you for your interest in contributing to 0x protocol! We welcome contributions from anyone on the internet, and are grateful for even the smallest of fixes!
+Thank you for your interest in contributing to 0x.js! We welcome contributions from anyone on the internet, and are grateful for even the smallest of fixes!
 
-### How to contribute
+## Developer's guide
 
-If you'd like to contribute to 0x protocol, please fork the repo, fix, commit and send a pull request against the `development` branch for the maintainers to review and merge into the main code base. If you wish to submit more complex changes though, please check with a core dev first on [our RocketChat #dev channel](http://chat.0xproject.com) to ensure those changes are in-line with the general philosophy of the project and/or to get some early feedback which can make both your efforts easier as well as our review and merge procedures quick and simple.
+## How to contribute
 
-We encourage a “PR early” approach so create the PR as early as possible even without the fix/feature ready, so that devs and other contributors know you have picked up the issue. These early PRs should indicate an 'in progress' status by adding the '[WIP]' prefix to the PR title. Please make sure your contributions adhere to our coding guidelines:
+If you'd like to contribute to 0x.js, please fork the repo, fix, commit and send a pull request against the `development` branch for the maintainers to review and merge into the main code base. If you wish to submit more complex changes though, please check up with a core dev first on [our gitter channel](https://gitter.im/0xProject/Lobby) or  in the `#dev` channel on our [slack](https://slack.0xproject.com/) to ensure those changes are in line with the general philosophy of the project and/or to get some early feedback which can make both your efforts easier as well as our review and merge procedures quick and simple.
 
-*   Pull requests adding features or refactoring should be opened against the `development` branch
-*   Pull requests fixing bugs in the latest release version should be opened again the `master` branch
-*   Write [good commit messages](https://chris.beams.io/posts/git-commit/)
+We encourage a “PR early” approach so create the PR as early as possible even without the fix/feature ready, so that devs and other volunteers know you have picked up the issue. These early PRs should indicate an 'in progress' status by adding the '[WIP]' prefix to the PR title. Please make sure your contributions adhere to our coding guidelines:
 
-### Code quality
+* Pull requests adding features or refactoring should be opened against the `development` branch
+* Pull requests fixing bugs in the latest release version should be opened again the `master` branch
+* Write [good commit messages](https://chris.beams.io/posts/git-commit/)
 
-Because 0x.js is used by multiple relayers in production and their businesses depend on it, we strive for exceptional code quality. Please follow the existing code standards and conventions. `tslint` and `prettier` (described below) will help you.
+## Code quality
 
+Because 0x.js is used by multiple relayers in production and their businesses depend on it, we strive for excellent code quality. Please follow the existing code standards and conventions. `tslint` (described below) will help you.
 If you're adding functionality, please also add tests and make sure they pass. We have an automatic coverage reporting tool, so we'll see it if they are missing ;)
 If you're adding a new public function/member, make sure you document it with Java doc-style comments. We use typedoc to generate [awesome documentation](https://0xproject.com/docs/0xjs) from the comments within our source code.
 
-If the sub-package you are modifying has a `CHANGELOG.md` file, make sure to add an entry in it for the change made to the package. For published packages, only changes that modify the public interface or behavior of the package need a CHANGELOG entry.
+## Running and building
 
-### Styleguide
+First thing to do with an unknown code base is to run the tests.
+We assume that you have `npm` and `yarn` installed.
 
-We use [TSLint](https://palantir.github.io/tslint/) with [custom configs](https://github.com/0xProject/0x-monorepo/tree/development/packages/tslint-config) to keep our code style consistent.
+To do that:
+
+* Install dependencies: `yarn`
+* Initialize the testrpc state (migrate the contracts) by doing one of the following:
+    * Manual contracts migration:
+        * Run testrpc: `yarn testrpc`
+        * Clone the `[contracts](https://github.com/0xProject/contracts)` repo and run `yarn migrate`
+    * Use one of the existing testrpc snapshots
+        * Check out `circle.yml` for an example
+* Run tests: `yarn test`
+
+To build run: `yarn build`
+
+We also recommend you read through the tests.
+
+## Styleguide
+
+We use `[tslint](https://palantir.github.io/tslint/)` with [custom configs](https://github.com/0xProject/tslint-config-0xproject) to keep our code style consistent.
 
 To lint your code just run: `yarn lint`
 
-We also use [Prettier](https://prettier.io/) to auto-format our code. Be sure to either add a [text editor integration](https://prettier.io/docs/en/editors.html) or a [pre-commit hook](https://prettier.io/docs/en/precommit.html) to properly format your code changes.
-
 If using the Atom text editor, we recommend you install the following packages:
 
-*   [atom-typescript](https://atom.io/packages/atom-typescript)
-*   [linter-tslint](https://atom.io/packages/linter-tslint)
-*   [prettier-atom](https://atom.io/packages/prettier-atom)
-*   [language-ethereum](https://atom.io/packages/language-ethereum)
+* [atom-typescript](https://atom.io/packages/atom-typescript)
+* [linter-tslint](https://atom.io/packages/linter-tslint)
 
-Our CI will also run TSLint and Prettier as a part of the test run when you submit your PR. Make sure that the CI tests pass for your contribution.
+Our CI will also run it as a part of the test run when you submit your PR.
 
-### Branch structure & versioning
 
-We use [semantic versioning](http://semver.org/), but before a package reaches v1.0.0 all breaking changes as well as new features will be minor version bumps.
+## Branch structure & versioning
+
+We use [semantic versioning](http://semver.org/), but before we reach v1.0.0 all breaking changes as well as new features will be minor version bumps.
 
 We have two main branches: `master` and `development`.
 

ISSUE_TEMPLATE.md

@@ -1,62 +0,0 @@
-<!--- Thank you for taking the time to file an Issue -->
-
-<!--- Before submitting please check to see if this issue was already reported -->
-
-<!--- Provide a general summary of the issue in the Title above -->
-
-## Expected Behavior
-
-<!--- If you're describing a bug, tell us what should happen -->
-
-<!--- If you're suggesting a package change/improvement, tell us how it should work -->
-
-<!--- If you're suggesting a contract or protocol change/improvement, visit our ZEIPs repo -->
-
-## Current Behavior
-
-<!--- If describing a bug, tell us what happens instead of the expected behavior -->
-
-<!--- If suggesting a change/improvement, explain the difference from current behavior -->
-
-## Possible Solution
-
-<!--- Not obligatory, but suggest a fix/reason for the bug, -->
-
-<!--- or ideas how to implement the addition or change -->
-
-## Steps to Reproduce (for bugs)
-
-<!--- Provide a link to a live example, or an unambiguous set of steps to -->
-
-<!--- reproduce this bug. Include code to reproduce, if relevant -->
-
-```
-1.
-2.
-3.
-```
-
-## Context
-
-<!--- How has this issue affected you? What are you trying to accomplish? -->
-
-<!--- Providing context helps us come up with a solution that is most useful in the real world -->
-
-## Your Environment
-
-<!--- Include as many relevant details about the environment you experienced the bug in -->
-
-|             Package | Version |
-| ------------------: | :------ |
-|             `0x.js` | 0.25.0  |
-| `Exchange Contract` | v1      |
-
-| Network |
-| ------- |
-| NAME    |
-
-<!-- For example:
-| mainnet |
-| kovan |
-| testrpc |
--->

PULL_REQUEST_TEMPLATE.md

@@ -1,42 +1,2 @@
-<!--- Thank you for taking the time to submit a Pull Request -->
-
-<!--- Provide a general summary of the issue in the Title above -->
-
-## Description
-
-<!--- Describe your changes in detail -->
-
-## Motivation and Context
-
-<!--- Why is this change required? What problem does it solve? -->
-
-<!--- If it fixes an open issue, please link to the issue here. -->
-
-## How Has This Been Tested?
-
-<!--- Please describe in detail how you tested your changes. -->
-
-<!--- Include details of your testing environment, and the tests you ran to -->
-
-<!--- see how your change affects other areas of the code, etc. -->
-
-## Types of changes
-
-<!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply: -->
-
-*   [ ] Bug fix (non-breaking change which fixes an issue)
-*   [ ] New feature (non-breaking change which adds functionality)
-*   [ ] Breaking change (fix or feature that would cause existing functionality to change)
-
-## Checklist:
-
-<!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
-
-<!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
-
-*   [ ] Change requires a change to the documentation.
-*   [ ] Added tests to cover my changes.
-*   [ ] Added new entries to the relevant CHANGELOGs.
-*   [ ] Updated the new versions of the changed packages in the relevant CHANGELOGs.
-*   [ ] Labeled this PR with the 'WIP' label if it is a work in progress.
-*   [ ] Labeled this PR with the labels corresponding to the changed package.
+This PR:
+* 

README.md

@@ -4,138 +4,24 @@
 
 [0x][website-url] is an open protocol that facilitates trustless, low friction exchange of Ethereum-based assets. A full description of the protocol may be found in our [whitepaper][whitepaper-url].
 
-This repository is a monorepo including the 0x protocol smart contracts and numerous developer tools. Each public sub-package is independently published to NPM.
+This repository contains all the 0x developer tools written in TypeScript. Our hope is that these tools make it easy to build Relayers and other DApps that use the 0x protocol.
 
 [website-url]: https://0xproject.com/
 [whitepaper-url]: https://0xproject.com/pdfs/0x_white_paper.pdf
 
-[![CircleCI](https://circleci.com/gh/0xProject/0x-monorepo.svg?style=svg&circle-token=61bf7cd8c9b4e11b132089dfcffdd1be277d1e0c)](https://circleci.com/gh/0xProject/0x-monorepo)
-[![Coverage Status](https://coveralls.io/repos/github/0xProject/0x-monorepo/badge.svg?branch=development)](https://coveralls.io/github/0xProject/0x-monorepo?branch=development)
-[![Discord](https://img.shields.io/badge/chat-rocket.chat-yellow.svg?style=flat)](https://chat.0xproject.com)
+[![CircleCI](https://circleci.com/gh/0xProject/0x.js.svg?style=svg&circle-token=61bf7cd8c9b4e11b132089dfcffdd1be277d1e0c)](https://circleci.com/gh/0xProject/0x.js)
+[![Coverage Status](https://coveralls.io/repos/github/0xProject/0x.js/badge.svg?branch=master&t=fp0cXD)](https://coveralls.io/github/0xProject/0x.js?branch=master)
+[![Discord](https://img.shields.io/badge/chat-rocket.chat-yellow.svg?style=flat
+)](https://chat.0xproject.com)
 [![Join the chat at https://gitter.im/0xProject/Lobby](https://badges.gitter.im/0xProject/Lobby.svg)](https://gitter.im/0xProject/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-[![Greenkeeper badge](https://badges.greenkeeper.io/0xProject/0x-monorepo.svg?token=7c22e5c72acf39d3ead8d29c5d9bb38f9096df3e643024dcedd53ab732847be1&ts=1496426342666)](https://greenkeeper.io/)
+[![Greenkeeper badge](https://badges.greenkeeper.io/0xProject/0x.js.svg?token=7c22e5c72acf39d3ead8d29c5d9bb38f9096df3e643024dcedd53ab732847be1&ts=1496426342666)](https://greenkeeper.io/)
 
-### Published Packages
+### Core 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 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
-
-| Package                                                         | Description                                                      |
-| --------------------------------------------------------------- | ---------------------------------------------------------------- |
-| [`@0xproject/contracts`](/packages/contracts)                   | 0x solidity smart contracts & tests                              |
-| [`@0xproject/react-docs-example`](/packages/react-docs-example) | Example documentation site created with `@0xproject/react-docs`  |
-| [`@0xproject/testnet-faucets`](/packages/testnet-faucets)       | A faucet micro-service that dispenses test ERC20 tokens or Ether |
-| [`@0xproject/website`](/packages/website)                       | 0x website & Portal DApp                                         |
-
-## Usage
-
-Dedicated documentation pages:
-
-*   [0x.js Library](https://0xproject.com/docs/0xjs)
-*   [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)
-*   [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)
-
-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.
-
-```json
-"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
-
-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.
-
-```bash
-yarn lerna:rebuild
-```
-
-Or continuously rebuild on change:
-
-```bash
-yarn dev
-```
-
-### Lint
-
-Lint all packages
-
-```bash
-yarn lerna:run lint
-```
-
-### Run Tests
-
-Before running the tests, you will need to spin up a [TestRPC](https://www.npmjs.com/package/ethereumjs-testrpc) instance and deploy all the 0x smart contracts.
-
-In a separate terminal, start TestRPC (a convenience command is provided as part of this repo)
-
-```bash
-yarn testrpc
-```
-
-Then in your main terminal run
-
-```
-cd packages/contracts
-yarn migrate
-cd ..
-```
-
-And finally from the root project directory run
-
-```bash
-yarn lerna:run test
-```
+| Package | Version | Description |
+|--------|-------|------------|
+| [`0x.js`](/packages/0x.js) | [![npm](https://img.shields.io/npm/v/0x.js.svg?maxAge=2592000)](https://www.npmjs.com/package/0x.js) | A Javascript library for interacting with the 0x protocol |
+| [`@0xproject/assert`](/packages/assert) | [![npm](https://img.shields.io/npm/v/@0xproject/assert.svg?maxAge=2592000)](https://www.npmjs.com/package/@0xproject/assert) | Standard type and schema assertions |
+| [`@0xproject/json-schemas`](/packages/json-schemas) | [![npm](https://img.shields.io/npm/v/@0xproject/json-schemas.svg?maxAge=2592000)](https://www.npmjs.com/package/@0xproject/json-schemas) | 0x-related json schemas |
+| [`@0xproject/tslint-config`](/packages/tslint-config) | [![npm](https://img.shields.io/npm/v/@0xproject/tslint-config.svg?maxAge=2592000)](https://www.npmjs.com/package/@0xproject/tslint-config) | Custom 0x project TSLint rules |

lerna.json

@@ -1,17 +1,9 @@
 {
-    "lerna": "2.5.1",
-    "packages": ["packages/*"],
-    "commands": {
-        "publish": {
-            "allowBranch": "development"
-        }
-    },
-    "version": "independent",
-    "commands": {
-        "publish": {
-            "ignore": ["test/**/*", "*.md", "scripts", "lib", "tslint.json", "tsconfig.json"]
-        }
-    },
-    "npmClient": "yarn",
-    "useWorkspaces": true
+  "lerna": "2.5.1",
+  "packages": [
+    "packages/*"
+  ],
+  "version": "independent",
+  "npmClient": "yarn",
+  "useWorkspaces": true
 }

package.json

@@ -1,36 +1,22 @@
 {
     "private": true,
-    "name": "0x-monorepo",
+    "name": "0x.js",
     "workspaces": [
         "packages/*"
     ],
     "scripts": {
-        "dev": "lerna run --parallel build:watch",
         "testrpc": "testrpc -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: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",
-        "script:publish": "node ./packages/monorepo-scripts/lib/publish.js",
-        "script:publish:dry": "IS_DRY_RUN=true yarn script:publish"
+        "lerna:publish": "lerna run clean; lerna run build; lerna publish"
     },
     "config": {
-        "mnemonic": "concert load couple harbor equip island argue ramp clarify fence smart topic"
+      "mnemonic": "concert load couple harbor equip island argue ramp clarify fence smart topic"
     },
     "devDependencies": {
-        "async-child-process": "^1.1.1",
-        "coveralls": "^3.0.0",
-        "ethereumjs-testrpc": "^6.0.3",
-        "lcov-result-merger": "^2.0.0",
         "lerna": "^2.5.1",
-        "npm-run-all": "^4.1.2",
-        "prettier": "^1.11.1"
+        "async-child-process": "^1.1.1",
+        "semver-sort": "^0.0.4",
+        "publish-release": "0xproject/publish-release",
+        "es6-promisify": "^5.0.0"
     }
 }

packages/0x.js/.npmignore

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

packages/0x.js/CHANGELOG.md

@@ -1,257 +1,149 @@
-<!--
-This file is auto-generated using the monorepo-scripts package. Don't edit directly.
-Edit the package's CHANGELOG.json file only.
--->
-
-CHANGELOG
-
-## v0.35.0 - _April 2, 2018_
-
-    * Removed `ZeroExError.TransactionMiningTimeout` and moved it to '@0xproject/web3_wrapper' `Web3WrapperErrors.TransactionMiningTimeout` (#485)
-
-## v0.34.0 - _April 2, 2018_
-
-    * Fix the bug causing `zeroEx.exchange.fillOrdersUpToAsync` validation to fail if there were some extra orders passed (#470)
-    * Remove automatic instantiation of `zeroEx.orderStateWatcher` (#488)
-    * Add `zeroEx.createOrderStateWatcher` to allow creating arbitrary number of OrderStateWatchers (#488)
-    * Added `stateLayer` setting to `OrderStateWatcherConfig` so OrderStateWatcher can be set to monitor different blockchain state layers (#488)
-
-## v0.33.2 - _March 17, 2018_
-
-    * Consolidate all `console.log` calls into `logUtils` in the `@0xproject/utils` package (#452)
-    * Consolidate `Order`, `SignedOrder`, and `ECSignature` into the `@0xproject/types` package (#456)
-
-## v0.33.1 - _March 7, 2018_
-
-    * Add missing EthersJs typescript typings as dependency
-
-## v0.33.0 - _March 3, 2018_
-
-    * Validate and lowercase all addresses in public methods (#373)
-    * Improve validation to force passing contract addresses on private networks (#385)
-    * Change `LogErrorContractEventArgs.errorId` type from `BigNumber` to `number` (#413)
-    * Rename all public `_unsubscribeAll` methods to `unsubscribeAll` (#415)
-    * Move web3 typings from devDep to dep since cannot use this package without it (#429)
-
-## v0.32.2 - _February 8, 2018_
-
-    * Fix publishing issue where .npmignore was not properly excluding undesired content (#389)
-
-## v0.32.1 - _February 6, 2018_
-
-    * Reorganized `BlockParamLiteral` export into `@0xproject/types` package (#355)
-    * Now using `abi-gen` package to generate ContractEventArgs types (#371)
-
-## v0.32.0 - _February 4, 2018_
-
-    * Add `zeroEx.etherToken.getContractAddressIfExists` (#350)
-    * Fixed the bug causing order watcher to throw if there is an event with the same signature but different indexed fields (#366)
-
-## v0.31.1 - _January 31, 2018_
-
-    * Fix the bug causing order watcher to throw if makerToken === zrx (#357)
-
-## v0.31.0 - _January 29, 2018_
-
-    * Add the `shouldAddPersonalMessagePrefix` parameter to `signOrderHashAsync` so that the caller can decide on whether to add the personalMessage prefix before relaying the request to the signer. Parity Signer, Ledger and TestRPC add the prefix themselves, Metamask expects it to have already been added. (#349)
-
-## v0.30.2 - _January 28, 2018_
-
-    * Add Rinkeby testnet addresses to artifacts  (#337)
-    * Move @0xproject/types to dependencies from devDependencies fixing missing type errors
-
-## v0.30.1 - _January 23, 2018_
-
-    * Fix a bug allowing negative fill values  (#212)
-    * Fix a bug that made it impossible to pass a custom ZRX address  (#341)
-
-## v0.30.0 - _January 16, 2018_
-
-    * Add an error parameter to the order watcher callback (#312)
-    * Fix a bug making it impossible to catch some errors from awaitTransactionMinedAsync (#312)
-    * Fix a bug in fillOrdersUpTo validation making it impossible to fill up to if user doesn't have enough balance to fully fill all the orders (#321)
-
-## v0.29.1 - _January 10, 2018_
-
-    * Fixed bignumber config issue #301 (#305)
-
-## v0.29.0 - _December 27, 2017_
-
-    * Assert baseUnit amount supplied to `toUnitAmount` is integer amount. (#287)
-    * `toBaseUnitAmount` throws if amount supplied has too many decimals (#287)
-
-## v0.28.0 - _December 19, 2017_
-
-    * Add `etherTokenAddress` arg to `depositAsync` and `withdrawAsync` methods on `zeroEx.etherToken` (#267)
-    * Removed accidentally included `unsubscribeAll` method from `zeroEx.proxy`, `zeroEx.etherToken` and `zeroEx.tokenRegistry` (#267)
-    * Removed `etherTokenContractAddress` from `ZeroEx` constructor arg `ZeroExConfig` (#267)
-    * Rename `SubscriptionOpts` to `BlockRange` (#272)
-    * Add `zeroEx.etherToken.subscribe`, `zeroEx.etherToken.unsubscribe`, `zeroEx.etherToken.unsubscribeAll` (#277)
-    * Add `zeroEx.etherToken.getLogsAsync` (#277)
-    * Add new public types `BlockParamLiteral`, `EtherTokenEvents`, `EtherTokenContractEventArgs`, `DepositContractEventArgs`, `WithdrawalContractEventArgs` (#277)
-    * Support `Deposit` and `Withdraw` events on etherToken (#277)
-    * Improve the error message when taker is not a string (#278)
-
-## v0.27.1 - _November 27, 2017_
-
-    * Export `TransactionOpts` type
-
-## v0.27.0 - _November 27, 2017_
-
-    * Make `ZeroExConfig` required parameter of `ZeroEx` constructor (#233)
-    * Add a required property `networkId` to `ZeroExConfig` (#233)
-    * Make all `getContractAddress` functions, `zeroEx.exchange.subscribe`, `zeroEx.exchange.getZRXTokenAddress` sync (#233)
-    * Remove `ZeroExError.ContractNotFound` and replace it with contract-specific errors (#233)
-    * Make `DecodedLogEvent<A>` contain `LogWithDecodedArgs<A>` under log key instead of merging it in like web3 does (#234)
-    * Rename `removed` to `isRemoved` in `DecodedLogEvent<A>` (#234)
-    * Add config allowing to specify gasPrice and gasLimit for every transaction sending method (#235)
-    * All transaction sending methods now call `estimateGas` if no gas amount was supplied (#235)
-    * Modify order validation methods to validate against the `latest` block, not against the `pending` block (#236)
-
-## v0.26.0 - _November 20, 2017_
+# CHANGELOG
 
+vx.x.x
+------------------------
     * Add post-formatter for logs converting `blockNumber`, `logIndex`, `transactionIndex` from hexes to numbers (#231)
     * Remove support for Async callback types when used in Subscribe functions (#222)
     * In OrderWatcher subscribe to ZRX Token Transfer and Approval events when maker token is different (#225)
 
-## v0.25.1 - _November 12, 2017_
-
+v0.25.1 - _November 13, 2017_
+------------------------
     * Standardise on Cancelled over Canceled (#217)
     * Add missing `DecodedLogEvent` type to exported types (#205)
     * Normalized the transactionReceipt status to be `null|0|1`, 1 meaning transaction execution successful, 0 unsuccessful and `null` if it is a pre-byzantinium transaction. (#200)
 
-## v0.23.0 - _November 11, 2017_
-
+v0.23.0 - _November 12, 2017_
+------------------------
     * Fixed unhandled promise rejection error in subscribe methods (#209)
     * Subscribe callbacks now receive an error object as their first argument
 
-## v0.22.6 - _November 9, 2017_
-
+v0.22.6 - _November 10, 2017_
+------------------------
     * Add a timeout parameter to transaction awaiting (#206)
 
-## v0.22.5 - _November 6, 2017_
-
+v0.22.5 - _November 7, 2017_
+------------------------
     * Re-publish v0.22.4 to fix publishing issue
 
-## v0.22.4 - _October 24, 2017_
-
+v0.22.4 - _October 25, 2017_
+------------------------
     * Upgraded bignumber.js to a new version that ships with native typings
 
-## v0.22.3 - _October 24, 2017_
-
+v0.22.3 - _October 25, 2017_
+------------------------
     * Fixed an issue with new version of testrpc and unlimited proxy allowance (#199)
 
-## v0.22.2 - _October 23, 2017_
-
+v0.22.2 - _October 24, 2017_
+------------------------
     * Fixed rounding of maker fill amount and incorrect validation of partial fees (#197)
 
-## v0.22.0 - _October 15, 2017_
-
+v0.22.0 - _October 16, 2017_
+------------------------
     * Started using `OrderFillRequest` interface instead of `OrderFillOrKillRequest` interface for `zeroEx.exchange.batchFillOrKill` (#187)
     * Removed `OrderFillOrKillRequest` (#187)
 
-## v0.21.4 - _October 12, 2017_
-
+v0.21.4 - _October 13, 2017_
+------------------------
     * Made 0x.js more type-safe by making `getLogsAsync` and `subscribe/subscribeAsync` generics parametrized with arg type (#194)
 
-## v0.21.3 - _October 11, 2017_
-
+v0.21.3 - _October 12, 2017_
+------------------------
     * Fixed a bug causing order fills to throw `INSUFFICIENT_TAKER_ALLOWANCE` (#193)
 
-## v0.21.2 - _October 10, 2017_
-
+v0.21.2 - _October 11, 2017_
+------------------------
     * Exported `ContractEventArg` as a public type (#190)
 
-## v0.21.1 - _October 10, 2017_
-
+v0.21.1 - _October 11, 2017_
+------------------------
     * Fixed a bug in subscriptions (#189)
 
-## v0.21.0 - _October 9, 2017_
-
+v0.21.0 - _October 10, 2017_
+------------------------
     * Complete rewrite of subscription logic (#182)
-    * Subscriptions no longer return historical logs. If you want them - use `getLogsAsync`
-    * Subscriptions now use [ethereumjs-blockstream](https://github.com/ethereumjs/ethereumjs-blockstream) under the hood
-    * Subscriptions correctly handle block re-orgs (forks)
-    * Subscriptions correctly backfill logs (connection problems)
-    * They no longer setup filters on the underlying nodes, so you can use them with infura without a filter Subprovider
-    * Removed `ContractEventEmitter` and added `LogEvent`
-    * Renamed `zeroEx.token.subscribeAsync` to `zeroEx.token.subscribe`
-    * Added `zeroEx.token.unsubscribe` and `zeroEx.exchange.unsubscribe`
-    * Renamed `zeroEx.exchange.stopWatchingAllEventsAsync` to `zeroEx.exhange.unsubscribeAll`
-    * Renamed `zeroEx.token.stopWatchingAllEventsAsync` to `zeroEx.token.unsubscribeAll`
+        * Subscriptions no longer return historical logs. If you want them - use `getLogsAsync`
+        * Subscriptions now use [ethereumjs-blockstream](https://github.com/ethereumjs/ethereumjs-blockstream) under the hood
+            * Subscriptions correctly handle block re-orgs (forks)
+            * Subscriptions correctly backfill logs (connection problems)
+            * They no longer setup filters on the underlying nodes, so you can use them with infura without a filter Subprovider
+        * Removed `ContractEventEmitter` and added `LogEvent`
+        * Renamed `zeroEx.token.subscribeAsync` to `zeroEx.token.subscribe`
+        * Added `zeroEx.token.unsubscribe` and `zeroEx.exchange.unsubscribe`
+        * Renamed `zeroEx.exchange.stopWatchingAllEventsAsync` to `zeroEx.exhange.unsubscribeAll`
+        * Renamed `zeroEx.token.stopWatchingAllEventsAsync` to `zeroEx.token.unsubscribeAll`
     * Fixed the batch fills validation by emulating all balance & proxy allowance changes (#185)
 
-## v0.20.0 - _October 4, 2017_
-
+v0.20.0 - _October 5, 2017_
+------------------------
     * Add `zeroEx.token.getLogsAsync` (#178)
     * Add `zeroEx.exchange.getLogsAsync` (#178)
     * Fixed fees validation when one of the tokens transferred is ZRX (#181)
 
-## v0.19.0 - _September 28, 2017_
-
+v0.19.0 - _September 29, 2017_
+------------------------
     * Made order validation optional  (#172)
     * Added Ropsten testnet support (#173)
     * Fixed a bug causing awaitTransactionMinedAsync to DDos backend nodes (#175)
 
-## v0.18.0 - _September 25, 2017_
-
+v0.18.0 - _September 26, 2017_
+------------------------
     * Added `zeroEx.exchange.validateOrderFillableOrThrowAsync` to simplify orderbook pruning (#170)
 
-## v0.17.0 - _September 25, 2017_
-
+v0.17.0 - _September 26, 2017_
+------------------------
     * Made `zeroEx.exchange.getZRXTokenAddressAsync` public (#171)
 
-## v0.16.0 - _September 19, 2017_
-
+v0.16.0 - _September 20, 2017_
+------------------------
     * Added the ability to specify custom contract addresses to be used with 0x.js (#165)
-    * ZeroExConfig.exchangeContractAddress
-    * ZeroExConfig.tokenRegistryContractAddress
-    * ZeroExConfig.etherTokenContractAddress
+        * ZeroExConfig.exchangeContractAddress
+        * ZeroExConfig.tokenRegistryContractAddress
+        * ZeroExConfig.etherTokenContractAddress
     * Added `zeroEx.tokenRegistry.getContractAddressAsync` (#165)
 
-## v0.15.0 - _September 7, 2017_
-
+v0.15.0 - _September 8, 2017_
+------------------------
     * Added the ability to specify a historical `blockNumber` at which to query the blockchain's state when calling a token or exchange method (#161)
 
-## v0.14.2 - _September 6, 2017_
-
+v0.14.2 - _September 7, 2017_
+------------------------
     * Fixed an issue with bignumber.js types not found (#160)
 
-## v0.14.1 - _September 6, 2017_
-
+v0.14.1 - _September 7, 2017_
+------------------------
     * Fixed an issue with Artifact type not found (#159)
 
-## v0.14.0 - _September 5, 2017_
-
+v0.14.0 - _September 6, 2017_
+------------------------
     * Added `zeroEx.exchange.throwLogErrorsAsErrors` method to public interface (#157)
     * Fixed an issue with overlapping async intervals in `zeroEx.awaitTransactionMinedAsync` (#157)
     * Fixed an issue with log decoder returning `BigNumber`s as `strings` (#157)
 
-## v0.13.0 - _September 5, 2017_
-
+v0.13.0 - _September 6, 2017_
+------------------------
     * Made all the functions submitting transactions to the network to immediately return transaction hash (#151)
     * Added `zeroEx.awaitTransactionMinedAsync` (#151)
     * Added `TransactionReceiptWithDecodedLogs`, `LogWithDecodedArgs`, `DecodedLogArgs` to public types (#151)
     * Added signature validation to `validateFillOrderThrowIfInvalidAsync` (#152)
 
-## v0.12.1 - _September 1, 2017_
-
+v0.12.1 - _September 2, 2017_
+------------------------
     * Added the support for web3@1.x.x provider (#142)
     * Added the optional `zeroExConfig`  parameter to the constructor of `ZeroEx` (#139)
     * Added the ability to specify `gasPrice` when instantiating `ZeroEx` (#139)
 
-## v0.11.0 - _August 23, 2017_
-
+v0.11.0 - _August 24, 2017_
+------------------------
     * Added `zeroEx.token.setUnlimitedProxyAllowanceAsync` (#137)
     * Added `zeroEx.token.setUnlimitedAllowanceAsync` (#137)
     * Added `zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS` (#137)
 
-## v0.10.4 - _August 23, 2017_
-
+v0.10.4 - _Aug 24, 2017_
+------------------------
     * Fixed a bug where checksummed addresses were being pulled from artifacts and not lower-cased. (#135)
 
-## v0.10.1 - _August 23, 2017_
-
+v0.10.1 - _Aug 24, 2017_
+------------------------
     * Added `zeroEx.exchange.validateFillOrderThrowIfInvalidAsync` (#128)
     * Added `zeroEx.exchange.validateFillOrKillOrderThrowIfInvalidAsync` (#128)
     * Added `zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync` (#128)
@@ -265,21 +157,21 @@ CHANGELOG
     * Added clear error message when checksummed address is passed to a public method (#124)
     * Fixes the description of `shouldThrowOnInsufficientBalanceOrAllowance` in docs (#127)
 
-## v0.9.3 - _August 21, 2017_
-
+v0.9.3 - _Aug 22, 2017_
+------------------------
     * Update contract artifacts to include latest Kovan and Mainnet deploys (#118)
 
-## v0.9.2 - _August 20, 2017_
-
+v0.9.2 - _Aug 21, 2017_
+------------------------
     * *This version was unpublished because of a publishing issue.*
     * Update contract artifacts to include latest Kovan and Mainnet deploys (#118)
 
-## v0.9.1 - _August 15, 2017_
-
+v0.9.1 - _Aug. 16, 2017_
+------------------------
     * Fixed the bug causing `zeroEx.token.getBalanceAsync()` to fail if no addresses available (#120)
 
-## v0.9.0 - _July 25, 2017_
-
+v0.9.0 - _Jul. 26, 2017_
+------------------------
     * Migrated to the new version of smart contracts (#101)
     * Removed the ability to call methods on multiple authorized Exchange smart contracts (#106)
     * Made `zeroEx.getOrderHashHex` a static method (#107)
@@ -289,48 +181,48 @@ CHANGELOG
     * Updated to typescript v2.4 (#104)
     * Fixed an issue with incorrect balance/allowance validation when ZRX is one of the tokens traded (#109)
 
-## v0.8.0 - _July 3, 2017_
-
+v0.8.0 - _Jul. 4, 2017_
+------------------------
     * Added the ability to call methods on different authorized versions of the Exchange smart contract (#82)
     * Updated contract artifacts to reflect latest changes to the smart contracts (0xproject/contracts#59)
     * Added `zeroEx.proxy.isAuthorizedAsync` and `zeroEx.proxy.getAuthorizedAddressesAsync` (#89)
     * Added `zeroEx.token.subscribeAsync` (#90)
     * Made contract invalidation functions private (#90)
-    * `zeroEx.token.invalidateContractInstancesAsync`
-    * `zeroEx.exchange.invalidateContractInstancesAsync`
-    * `zeroEx.proxy.invalidateContractInstance`
-    * `zeroEx.tokenRegistry.invalidateContractInstance`
+        * `zeroEx.token.invalidateContractInstancesAsync`
+        * `zeroEx.exchange.invalidateContractInstancesAsync`
+        * `zeroEx.proxy.invalidateContractInstance`
+        * `zeroEx.tokenRegistry.invalidateContractInstance`
     * Fixed the bug where `zeroEx.setProviderAsync` didn't invalidate etherToken contract's instance
 
-## v0.7.1 - _June 25, 2017_
-
+v0.7.1 - _Jun. 26, 2017_
+------------------------
     * Added the ability to convert Ether to wrapped Ether tokens and back via `zeroEx.etherToken.depostAsync` and `zeroEx.etherToken.withdrawAsync` (#81)
 
-## v0.7.0 - _June 21, 2017_
-
+v0.7.0 - _Jun. 22, 2017_
+------------------------
     * Added Kovan smart contract artifacts (#78)
     * Started returning fillAmount from `fillOrderAsync` and `fillUpToAsync` (#72)
     * Started returning cancelledAmount from `cancelOrderAsync` (#72)
     * Renamed type `LogCancelArgs` to `LogCancelContractEventArgs` and `LogFillArgs` to `LogFillContractEventArgs`
 
-## v0.6.2 - _June 20, 2017_
-
+v0.6.2 - _Jun. 21, 2017_
+------------------------
     * Reduced bundle size
     * Improved documentation
 
-## v0.6.1 - _June 18, 2017_
-
+v0.6.1 - _Jun. 19, 2017_
+------------------------
     * Improved documentation
 
-## v0.6.0 - _June 18, 2017_
-
+v0.6.0 - _Jun. 19, 2017_
+------------------------
     * Made `ZeroEx` class accept `Web3Provider` instance instead of `Web3` instance
     * Added types for contract event arguments
 
-## v0.5.2 - _June 14, 2017_
-
+v0.5.2 - _Jun. 15, 2017_
+------------------------
     * Fixed the bug in `postpublish` script that caused that only unminified UMD bundle was uploaded to release page
 
-## v0.5.1 - _June 14, 2017_
-
+v0.5.1 - _Jun. 15, 2017_
+------------------------
     * Added `postpublish` script to publish to Github Releases with assets.

packages/0x.js/README.md

@@ -1,10 +1,11 @@
-## 0x.js
+0x.js
+-----
 
 ## Installation
 
 0x.js ships as both a [UMD](https://github.com/umdjs/umd) module and a [CommonJS](https://en.wikipedia.org/wiki/CommonJS) package.
 
-#### CommonJS _(recommended)_:
+#### CommonJS *(recommended)*:
 
 **Install**
 
@@ -15,22 +16,14 @@ npm install 0x.js --save
 **Import**
 
 ```javascript
-import { ZeroEx } from '0x.js';
-```
-
-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"],
-}
+import {ZeroEx} from '0x.js';
 ```
 
 #### UMD:
 
 **Install**
 
-Download the UMD module from our [releases page](https://github.com/0xProject/0x-monorepo/releases) and add it to your project.
+Download the UMD module from our [releases page](https://github.com/0xProject/0x.js/releases) and add it to your project.
 
 **Import**
 

packages/0x.js/package.json

@@ -1,120 +1,102 @@
 {
-    "name": "0x.js",
-    "version": "0.34.0",
-    "description": "A javascript library for interacting with the 0x protocol",
-    "keywords": [
-        "0x.js",
-        "0xproject",
-        "ethereum",
-        "tokens",
-        "exchange"
-    ],
-    "main": "lib/src/index.js",
-    "types": "lib/src/index.d.ts",
-    "scripts": {
-        "build: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/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'",
-        "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_contracts": "for i in ${npm_package_config_artifacts}; do copyfiles -u 4 ../contracts/build/contracts/$i.json ../0x.js/src/artifacts; done;",
-        "clean": "shx rm -rf _bundles lib test_temp scripts",
-        "build:umd:prod": "NODE_ENV=production webpack",
-        "build:commonjs": "tsc && copyfiles -u 2 './src/artifacts/**/*.json' ./lib/src/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",
-        "manual:postpublish": "yarn build; node ./scripts/postpublish.js",
-        "docs:stage": "yarn build && 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": {
-        "artifacts": "TokenTransferProxy Exchange TokenRegistry Token EtherToken",
-        "postpublish": {
-            "assets": [
-                "packages/0x.js/_bundles/index.js",
-                "packages/0x.js/_bundles/index.min.js"
-            ],
-            "docPublishConfigs": {
-                "extraFileIncludes": [
-                    "../types/src/index.ts",
-                    "./src/contract_wrappers/generated/ether_token.ts",
-                    "./src/contract_wrappers/generated/token.ts",
-                    "./src/contract_wrappers/generated/exchange.ts"
-                ],
-                "s3BucketPath": "s3://doc-jsons/0x.js/",
-                "s3StagingBucketPath": "s3://staging-doc-jsons/0x.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.8",
-        "@0xproject/dev-utils": "^0.3.3",
-        "@0xproject/monorepo-scripts": "^0.1.15",
-        "@0xproject/tslint-config": "^0.4.13",
-        "@types/bintrees": "^1.0.2",
-        "@types/jsonschema": "^1.1.1",
-        "@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",
-        "json-loader": "^0.5.4",
-        "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",
-        "request-promise-native": "^1.0.5",
-        "shx": "^0.2.2",
-        "sinon": "^4.0.0",
-        "source-map-support": "^0.5.0",
-        "truffle-hdwallet-provider": "^0.0.3",
-        "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.4",
-        "@0xproject/base-contract": "^0.0.6",
-        "@0xproject/json-schemas": "^0.7.18",
-        "@0xproject/types": "^0.4.2",
-        "@0xproject/typescript-typings": "^0.0.2",
-        "@0xproject/utils": "^0.4.4",
-        "@0xproject/web3-wrapper": "^0.4.0",
-        "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"
-    },
-    "publishConfig": {
-        "access": "public"
-    }
+  "name": "0x.js",
+  "version": "0.26.1",
+  "description": "A javascript library for interacting with the 0x protocol",
+  "keywords": [
+    "0x.js",
+    "0xproject",
+    "ethereum",
+    "tokens",
+    "exchange"
+  ],
+  "main": "lib/src/index.js",
+  "types": "lib/src/index.d.ts",
+  "scripts": {
+    "prebuild": "npm run clean",
+    "build": "run-p build:umd:prod build:commonjs; exit 0;",
+    "docs:json": "typedoc --excludePrivate --excludeExternals --target ES5 --json $JSON_FILE_PATH $PROJECT_DIR",
+    "upload_docs_json": "aws s3 cp docs/index.json $S3_URL --profile 0xproject --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers --content-type aplication/json",
+    "lint": "tslint src/**/*.ts test/**/*.ts",
+    "test:circleci": "run-s test:coverage report_test_coverage && if [ $CIRCLE_BRANCH = \"development\" ]; then yarn test:umd; fi",
+    "test": "run-s clean test:commonjs",
+    "test:umd": "./scripts/test_umd.sh",
+    "test:coverage": "nyc npm run test --all",
+    "report_test_coverage": "nyc report --reporter=text-lcov | coveralls",
+    "update_contracts": "for i in ${npm_package_config_artifacts}; do copyfiles -u 4 ../contracts/build/contracts/$i.json ../0x.js/src/artifacts; done;",
+    "clean": "shx rm -rf _bundles lib test_temp",
+    "build:umd:dev": "webpack",
+    "build:umd:prod": "NODE_ENV=production webpack",
+    "build:commonjs": "tsc && copyfiles -u 2 './src/artifacts/**/*.json' ./lib/src/artifacts;",
+    "test:commonjs": "run-s build:commonjs run_mocha",
+    "pretest:umd": "run-s clean build:umd:dev build:commonjs",
+    "substitute_umd_bundle": "shx mv _bundles/* lib/src",
+    "run_mocha": "mocha lib/test/**/*_test.js --timeout 5000 --bail --exit"
+  },
+  "config": {
+    "artifacts": "TokenTransferProxy Exchange TokenRegistry Token EtherToken"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/0xProject/0x.js"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "devDependencies": {
+    "@0xproject/tslint-config": "^0.1.1",
+    "@types/bintrees": "^1.0.2",
+    "@types/jsonschema": "^1.1.1",
+    "@types/lodash": "^4.14.64",
+    "@types/mocha": "^2.2.41",
+    "@types/node": "^8.0.1",
+    "@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-as-promised-typescript-typings": "0.0.3",
+    "chai-bignumber": "^2.0.1",
+    "chai-typescript-typings": "^0.0.1",
+    "copyfiles": "^1.2.0",
+    "coveralls": "^3.0.0",
+    "dirty-chai": "^2.0.1",
+    "ethereumjs-testrpc": "4.0.1",
+    "json-loader": "^0.5.4",
+    "mocha": "^4.0.0",
+    "npm-run-all": "^4.0.2",
+    "nyc": "^11.0.1",
+    "opn-cli": "^3.1.0",
+    "request": "^2.81.0",
+    "request-promise-native": "^1.0.4",
+    "shx": "^0.2.2",
+    "sinon": "^4.0.0",
+    "source-map-support": "^0.5.0",
+    "truffle-hdwallet-provider": "^0.0.3",
+    "tslint": "5.8.0",
+    "typedoc": "~0.8.0",
+    "types-bn": "^0.0.1",
+    "types-ethereumjs-util": "0xProject/types-ethereumjs-util",
+    "typescript": "~2.6.1",
+    "web3-provider-engine": "^13.0.1",
+    "web3-typescript-typings": "^0.7.1",
+    "webpack": "^3.1.0"
+  },
+  "dependencies": {
+    "@0xproject/assert": "^0.0.5",
+    "@0xproject/json-schemas": "^0.6.8",
+    "bignumber.js": "~4.1.0",
+    "bintrees": "^1.0.2",
+    "bn.js": "4.11.8",
+    "compare-versions": "^3.0.1",
+    "es6-promisify": "^5.0.0",
+    "ethereumjs-abi": "^0.6.4",
+    "ethereumjs-blockstream": "^2.0.6",
+    "ethereumjs-util": "^5.1.1",
+    "find-versions": "^2.0.0",
+    "js-sha3": "^0.6.1",
+    "lodash": "^4.17.4",
+    "uuid": "^3.1.0",
+    "web3": "^0.20.0"
+  }
 }

packages/0x.js/scripts/postpublish.js

@@ -0,0 +1,43 @@
+const execAsync = require('async-child-process').execAsync;
+const postpublish_utils = require('../../../scripts/postpublish_utils');
+const packageJSON = require('../package.json');
+
+const cwd = __dirname + '/..';
+const subPackageName = packageJSON.name;
+const S3BucketPath = 's3://0xjs-docs-jsons/';
+
+let tag;
+let version;
+postpublish_utils.getLatestTagAndVersionAsync(subPackageName)
+    .then(function(result) {
+        tag = result.tag;
+        version = result.version;
+         const releaseName = postpublish_utils.getReleaseName(subPackageName, version);
+         const assets = [
+             __dirname + '/../_bundles/index.js',
+             __dirname + '/../_bundles/index.min.js',
+         ];
+         return postpublish_utils.publishReleaseNotes(tag, releaseName, assets);
+    })
+    .then(function(release) {
+        console.log('POSTPUBLISH: Release successful, generating docs...');
+        return execAsync(
+            'JSON_FILE_PATH=' +  __dirname + '/../docs/index.json PROJECT_DIR=' + __dirname + '/.. yarn docs:json',
+            {
+                cwd,
+            }
+        );
+    })
+    .then(function(result) {
+        if (result.stderr !== '') {
+            throw new Error(result.stderr);
+        }
+        const fileName = 'v' + version + '.json';
+        console.log('POSTPUBLISH: Doc generation successful, uploading docs... as ', fileName);
+        const s3Url = S3BucketPath + fileName;
+        return execAsync('S3_URL=' + s3Url + ' yarn upload_docs_json', {
+            cwd,
+        });
+    }).catch (function(err) {
+        throw err;
+    });

packages/0x.js/scripts/test_umd.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# This script runs umd tests and cleans up after them while preserving the `return_code` for CI
+# UMD tests should only be run after building the commonjs because they reuse some of the commonjs build artifacts
+run-s substitute_umd_bundle run_mocha
+return_code=$?
+exit $return_code

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

@@ -1,26 +1,37 @@
-import { schemas, SchemaValidator } from '@0xproject/json-schemas';
-import { ECSignature, Order, SignedOrder, TransactionReceiptWithDecodedLogs } from '@0xproject/types';
-import { AbiDecoder, BigNumber, intervalUtils } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import * as ethUtil from 'ethereumjs-util';
 import * as _ from 'lodash';
+import BigNumber from 'bignumber.js';
+import {SchemaValidator, schemas} from '@0xproject/json-schemas';
+import {bigNumberConfigs} from './bignumber_config';
+import * as ethUtil from 'ethereumjs-util';
+import {Web3Wrapper} from './web3_wrapper';
+import {constants} from './utils/constants';
+import {utils} from './utils/utils';
+import {signatureUtils} from './utils/signature_utils';
+import {assert} from './utils/assert';
+import {AbiDecoder} from './utils/abi_decoder';
+import {intervalUtils} from './utils/interval_utils';
+import {artifacts} from './artifacts';
+import {ExchangeWrapper} from './contract_wrappers/exchange_wrapper';
+import {TokenRegistryWrapper} from './contract_wrappers/token_registry_wrapper';
+import {EtherTokenWrapper} from './contract_wrappers/ether_token_wrapper';
+import {TokenWrapper} from './contract_wrappers/token_wrapper';
+import {TokenTransferProxyWrapper} from './contract_wrappers/token_transfer_proxy_wrapper';
+import {OrderStateWatcher} from './order_watcher/order_state_watcher';
+import {OrderStateUtils} from './utils/order_state_utils';
+import {
+    ECSignature,
+    ZeroExError,
+    Order,
+    SignedOrder,
+    Web3Provider,
+    ZeroExConfig,
+    OrderStateWatcherConfig,
+    TransactionReceiptWithDecodedLogs,
+} from './types';
+import {zeroExConfigSchema} from './schemas/zero_ex_config_schema';
 
-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, Web3Provider, 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';
+// Customize our BigNumber instances
+bigNumberConfigs.configure();
 
 /**
  * The ZeroEx class is the single entry-point into the 0x.js library. It contains all of the library's functionality
@@ -57,7 +68,13 @@ export class ZeroEx {
      * tokenTransferProxy smart contract.
      */
     public proxy: TokenTransferProxyWrapper;
+    /**
+     * An instance of the OrderStateWatcher class containing methods for watching a set of orders for relevant
+     * blockchain state changes.
+     */
+    public orderStateWatcher: OrderStateWatcher;
     private _web3Wrapper: Web3Wrapper;
+    private _abiDecoder: AbiDecoder;
     /**
      * Verifies that the elliptic curve signature `signature` was generated
      * by signing `data` with the private key corresponding to the `signerAddress` address.
@@ -70,14 +87,13 @@ export class ZeroEx {
         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);
+        const isValidSignature = signatureUtils.isValidSignature(data, signature, signerAddress);
         return isValidSignature;
     }
     /**
      * Generates a pseudo-random 256-bit salt.
-     * The salt can be included in a 0x order, ensuring that the order generates a unique orderHash
+     * The salt can be included in an 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.
      */
@@ -113,7 +129,7 @@ export class ZeroEx {
      * @return  The amount in units.
      */
     public static toUnitAmount(amount: BigNumber, decimals: number): BigNumber {
-        assert.isValidBaseUnitAmount('amount', amount);
+        assert.isBigNumber('amount', amount);
         assert.isNumber('decimals', decimals);
 
         const aUnit = new BigNumber(10).pow(decimals);
@@ -134,10 +150,6 @@ export class ZeroEx {
 
         const unit = new BigNumber(10).pow(decimals);
         const baseUnitAmount = amount.times(unit);
-        const hasDecimals = baseUnitAmount.decimalPlaces() !== 0;
-        if (hasDecimals) {
-            throw new Error(`Invalid unit amount: ${amount.toString()} - Too many decimal places`);
-        }
         return baseUnitAmount;
     }
     /**
@@ -145,8 +157,7 @@ export class ZeroEx {
      * @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 {
+    public static getOrderHashHex(order: Order|SignedOrder): string {
         assert.doesConformToSchema('order', order, schemas.orderSchema);
         const orderHashHex = utils.getOrderHashHex(order);
         return orderHashHex;
@@ -158,59 +169,58 @@ 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: Web3Provider, config: ZeroExConfig) {
+    constructor(provider: Web3Provider, config?: ZeroExConfig) {
         assert.isWeb3Provider('provider', provider);
-        assert.doesConformToSchema('config', config, zeroExConfigSchema, [
-            zeroExPrivateNetworkConfigSchema,
-            zeroExPublicNetworkConfigSchema,
-        ]);
+        if (!_.isUndefined(config)) {
+            assert.doesConformToSchema('config', config, zeroExConfigSchema);
+        }
         const artifactJSONs = _.values(artifacts);
         const abiArrays = _.map(artifactJSONs, artifact => artifact.abi);
+        this._abiDecoder = new AbiDecoder(abiArrays);
+        const gasPrice = _.isUndefined(config) ? undefined : config.gasPrice;
         const defaults = {
-            gasPrice: config.gasPrice,
+            gasPrice,
         };
         this._web3Wrapper = new Web3Wrapper(provider, defaults);
-        _.forEach(abiArrays, abi => {
-            this._web3Wrapper.abiDecoder.addABI(abi);
-        });
-        this.proxy = new TokenTransferProxyWrapper(
+        this.token = new TokenWrapper(
             this._web3Wrapper,
-            config.networkId,
-            config.tokenTransferProxyContractAddress,
+            this._abiDecoder,
+            this._getTokenTransferProxyAddressAsync.bind(this),
         );
-        this.token = new TokenWrapper(this._web3Wrapper, config.networkId, this.proxy);
+        const exchageContractAddressIfExists = _.isUndefined(config) ? undefined : config.exchangeContractAddress;
         this.exchange = new ExchangeWrapper(
             this._web3Wrapper,
-            config.networkId,
+            this._abiDecoder,
             this.token,
-            config.exchangeContractAddress,
-            config.zrxContractAddress,
+            exchageContractAddressIfExists,
         );
-        this.tokenRegistry = new TokenRegistryWrapper(
+        this.proxy = new TokenTransferProxyWrapper(
             this._web3Wrapper,
-            config.networkId,
-            config.tokenRegistryContractAddress,
+            this._getTokenTransferProxyAddressAsync.bind(this),
+        );
+        const tokenRegistryContractAddressIfExists = _.isUndefined(config) ?
+                                                     undefined :
+                                                     config.tokenRegistryContractAddress;
+        this.tokenRegistry = new TokenRegistryWrapper(this._web3Wrapper, tokenRegistryContractAddressIfExists);
+        const etherTokenContractAddressIfExists = _.isUndefined(config) ? undefined : config.etherTokenContractAddress;
+        this.etherToken = new EtherTokenWrapper(this._web3Wrapper, this.token, etherTokenContractAddressIfExists);
+        const orderWatcherConfig = _.isUndefined(config) ? undefined : config.orderWatcherConfig;
+        this.orderStateWatcher = new OrderStateWatcher(
+            this._web3Wrapper, this._abiDecoder, this.token, this.exchange, orderWatcherConfig,
         );
-        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: Web3Provider, networkId: number): void {
+    public async setProviderAsync(provider: Web3Provider) {
         this._web3Wrapper.setProvider(provider);
-        (this.exchange as any)._invalidateContractInstances();
-        (this.exchange as any)._setNetworkId(networkId);
+        await (this.exchange as any)._invalidateContractInstancesAsync();
         (this.tokenRegistry as any)._invalidateContractInstance();
-        (this.tokenRegistry as any)._setNetworkId(networkId);
-        (this.token as any)._invalidateContractInstances();
-        (this.token as any)._setNetworkId(networkId);
+        await (this.token as any)._invalidateContractInstancesAsync();
         (this.proxy as any)._invalidateContractInstance();
-        (this.proxy as any)._setNetworkId(networkId);
         (this.etherToken as any)._invalidateContractInstance();
-        (this.etherToken as any)._setNetworkId(networkId);
     }
     /**
      * Get user Ethereum addresses available through the supplied web3 provider available for sending transactions.
@@ -226,29 +236,26 @@ export class ZeroEx {
      * @param   orderHash       Hex encoded orderHash to sign.
      * @param   signerAddress   The hex encoded Ethereum address you wish to sign it with. This address
      *          must be available via the Web3.Provider supplied to 0x.js.
-     * @param   shouldAddPersonalMessagePrefix  Some signers add the personal message prefix `\x19Ethereum Signed Message`
-     *          themselves (e.g Parity Signer, Ledger, TestRPC) and others expect it to already be done by the client
-     *          (e.g Metamask). Depending on which signer this request is going to, decide on whether to add the prefix
-     *          before sending the request.
      * @return  An object containing the Elliptic curve signature parameters generated by signing the orderHash.
      */
-    public async signOrderHashAsync(
-        orderHash: string,
-        signerAddress: string,
-        shouldAddPersonalMessagePrefix: boolean,
-    ): Promise<ECSignature> {
+    public async signOrderHashAsync(orderHash: string, signerAddress: string): Promise<ECSignature> {
         assert.isHexString('orderHash', orderHash);
         await assert.isSenderAddressAsync('signerAddress', signerAddress, this._web3Wrapper);
-        const normalizedSignerAddress = signerAddress.toLowerCase();
 
-        let msgHashHex = orderHash;
-        if (shouldAddPersonalMessagePrefix) {
+        let msgHashHex;
+        const nodeVersion = await this._web3Wrapper.getNodeVersionAsync();
+        const isParityNode = utils.isParityNode(nodeVersion);
+        const isTestRpc = utils.isTestRpc(nodeVersion);
+        if (isParityNode || isTestRpc) {
+            // Parity and TestRpc nodes add the personalMessage prefix itself
+            msgHashHex = orderHash;
+        } else {
             const orderHashBuff = ethUtil.toBuffer(orderHash);
             const msgHashBuff = ethUtil.hashPersonalMessage(orderHashBuff);
             msgHashHex = ethUtil.bufferToHex(msgHashBuff);
         }
 
-        const signature = await this._web3Wrapper.signMessageAsync(normalizedSignerAddress, msgHashHex);
+        const signature = await this._web3Wrapper.signTransactionAsync(signerAddress, 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)
@@ -257,7 +264,7 @@ export class ZeroEx {
         const validVParamValues = [27, 28];
         const ecSignatureVRS = signatureUtils.parseSignatureHexAsVRS(signature);
         if (_.includes(validVParamValues, ecSignatureVRS.v)) {
-            const isValidVRSSignature = ZeroEx.isValidSignature(orderHash, ecSignatureVRS, normalizedSignerAddress);
+            const isValidVRSSignature = ZeroEx.isValidSignature(orderHash, ecSignatureVRS, signerAddress);
             if (isValidVRSSignature) {
                 return ecSignatureVRS;
             }
@@ -265,7 +272,7 @@ export class ZeroEx {
 
         const ecSignatureRSV = signatureUtils.parseSignatureHexAsRSV(signature);
         if (_.includes(validVParamValues, ecSignatureRSV.v)) {
-            const isValidRSVSignature = ZeroEx.isValidSignature(orderHash, ecSignatureRSV, normalizedSignerAddress);
+            const isValidRSVSignature = ZeroEx.isValidSignature(orderHash, ecSignatureRSV, signerAddress);
             if (isValidRSVSignature) {
                 return ecSignatureRSV;
             }
@@ -281,25 +288,37 @@ export class ZeroEx {
      * @return  Transaction receipt with decoded log args.
      */
     public async awaitTransactionMinedAsync(
-        txHash: string,
-        pollingIntervalMs = 1000,
-        timeoutMs?: number,
-    ): Promise<TransactionReceiptWithDecodedLogs> {
-        const transactionReceiptWithDecodedLogs = await this._web3Wrapper.awaitTransactionMinedAsync(
-            txHash,
-            pollingIntervalMs,
-            timeoutMs,
-        );
-        return transactionReceiptWithDecodedLogs;
-    }
-    /**
-     * Instantiates and returns a new OrderStateWatcher 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.
-     */
-    public createOrderStateWatcher(config?: OrderStateWatcherConfig) {
-        return new OrderStateWatcher(this._web3Wrapper, this.token, this.exchange, config);
+        txHash: string, pollingIntervalMs = 1000, timeoutMs?: number): Promise<TransactionReceiptWithDecodedLogs> {
+        let timeoutExceeded = false;
+        if (timeoutMs) {
+            setTimeout(() => timeoutExceeded = true, timeoutMs);
+        }
+
+        const txReceiptPromise = new Promise(
+            (resolve: (receipt: TransactionReceiptWithDecodedLogs) => void, reject) => {
+            const intervalId = intervalUtils.setAsyncExcludingInterval(async () => {
+                if (timeoutExceeded) {
+                    intervalUtils.clearAsyncExcludingInterval(intervalId);
+                    return reject(ZeroExError.TransactionMiningTimeout);
+                }
+
+                const transactionReceipt = await this._web3Wrapper.getTransactionReceiptAsync(txHash);
+                if (!_.isNull(transactionReceipt)) {
+                    intervalUtils.clearAsyncExcludingInterval(intervalId);
+                    const logsWithDecodedArgs = _.map(
+                        transactionReceipt.logs,
+                        this._abiDecoder.tryToDecodeLogOrNoop.bind(this._abiDecoder),
+                    );
+                    const transactionReceiptWithDecodedLogArgs: TransactionReceiptWithDecodedLogs = {
+                        ...transactionReceipt,
+                        logs: logsWithDecodedArgs,
+                    };
+                    resolve(transactionReceiptWithDecodedLogArgs);
+                }
+            }, pollingIntervalMs);
+        });
+
+        return txReceiptPromise;
     }
     /*
      * HACK: `TokenWrapper` needs a token transfer proxy address. `TokenTransferProxy` address is fetched from

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

@@ -1,18 +1,14 @@
-import * as DummyTokenArtifact from './artifacts/DummyToken.json';
-import * as EtherTokenArtifact from './artifacts/EtherToken.json';
-import * as ExchangeArtifact from './artifacts/Exchange.json';
+import {Artifact} from './types';
 import * as TokenArtifact from './artifacts/Token.json';
+import * as ExchangeArtifact from './artifacts/Exchange.json';
+import * as EtherTokenArtifact from './artifacts/EtherToken.json';
 import * as TokenRegistryArtifact from './artifacts/TokenRegistry.json';
 import * as TokenTransferProxyArtifact from './artifacts/TokenTransferProxy.json';
-import * as ZRXArtifact from './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,
+    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/artifacts/DummyToken.json

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

packages/0x.js/src/artifacts/EtherToken.json

@@ -1,287 +1,445 @@
 {
-    "contract_name": "EtherToken",
-    "abi": [
+  "contract_name": "EtherToken",
+  "abi": [
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "name",
+      "outputs": [
         {
-            "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"
+          "name": "",
+          "type": "string"
         }
-    ],
-    "networks": {
-        "1": {
-            "address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+      ],
+      "payable": false,
+      "type": "function"
+    },
+    {
+      "constant": false,
+      "inputs": [
+        {
+          "name": "_spender",
+          "type": "address"
         },
-        "3": {
-            "address": "0xc00fd9820cd2898cc4c054b7bf142de637ad129a"
-        },
-        "4": {
-            "address": "0xc778417e063141139fce010982780140aa0cd5ab"
-        },
-        "42": {
-            "address": "0x653e49e301e508a13237c0ddc98ae7d4cd2667a1"
-        },
-        "50": {
-            "address": "0x871dd7c2b4b25e1aa18728e9d5f2af4c4e431f5c"
+        {
+          "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"
     }
+  ],
+  "unlinked_binary": "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",
+  "networks": {
+    "1": {
+      "links": {},
+      "events": {
+        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef": {
+          "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"
+        },
+        "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925": {
+          "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"
+        }
+      },
+      "updated_at": 1502488087000,
+      "address": "0x2956356cd2a2bf3202f771f50d3d14a367b48070"
+    },
+    "3": {
+      "links": {},
+      "events": {
+        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef": {
+          "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"
+        },
+        "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925": {
+          "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"
+        }
+      },
+      "updated_at": 1506602007000,
+      "address": "0xc00fd9820cd2898cc4c054b7bf142de637ad129a"
+    },
+    "42": {
+      "links": {},
+      "events": {
+        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef": {
+          "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"
+        },
+        "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925": {
+          "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"
+        }
+      },
+      "updated_at": 1502391794392,
+      "address": "0x05d090b51c40b020eab3bfcb6a2dff130df22e9c"
+    },
+    "50": {
+      "links": {},
+      "events": {
+        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef": {
+          "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"
+        },
+        "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925": {
+          "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"
+        }
+      },
+      "updated_at": 1503318938233,
+      "address": "0x48bacb9266a570d521063ef5dd96e61686dbe788"
+    }
+  },
+  "schema_version": "0.0.5",
+  "updated_at": 1503318938233
 }

packages/0x.js/src/artifacts/Token.json

@@ -1,172 +1,176 @@
 {
-    "contract_name": "Token",
-    "abi": [
+  "contract_name": "Token",
+  "abi": [
+    {
+      "constant": false,
+      "inputs": [
         {
-            "constant": false,
-            "inputs": [
-                {
-                    "name": "_spender",
-                    "type": "address"
-                },
-                {
-                    "name": "_value",
-                    "type": "uint256"
-                }
-            ],
-            "name": "approve",
-            "outputs": [
-                {
-                    "name": "success",
-                    "type": "bool"
-                }
-            ],
-            "payable": false,
-            "type": "function"
+          "name": "_spender",
+          "type": "address"
         },
         {
-            "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"
+          "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"
+    }
+  ],
+  "unlinked_binary": "0x6060604052341561000c57fe5b5b6101e08061001c6000396000f3006060604052361561005c5763ffffffff60e060020a600035041663095ea7b3811461005e57806318160ddd1461009157806323b872dd146100b357806370a08231146100ec578063a9059cbb1461005e578063dd62ed3e1461014d575bfe5b341561006657fe5b61007d600160a060020a0360043516602435610181565b604080519115158252519081900360200190f35b341561009957fe5b6100a161018a565b60408051918252519081900360200190f35b34156100bb57fe5b61007d600160a060020a0360043581169060243516604435610190565b604080519115158252519081900360200190f35b34156100f457fe5b6100a1600160a060020a036004351661019a565b60408051918252519081900360200190f35b341561006657fe5b61007d600160a060020a0360043516602435610181565b604080519115158252519081900360200190f35b341561015557fe5b6100a1600160a060020a0360043581169060243516610181565b60408051918252519081900360200190f35b60005b92915050565b60005b90565b60005b9392505050565b60005b919050565b60005b92915050565b60005b929150505600a165627a7a723058202e3f7ac17048343c0d0ea24fccb64620577374eeeed61539e543df4025d7d0db0029",
+  "networks": {},
+  "schema_version": "0.0.5",
+  "updated_at": 1503317882695
+}

packages/0x.js/src/artifacts/TokenTransferProxy.json

@@ -1,187 +1,174 @@
 {
-    "contract_name": "TokenTransferProxy",
-    "abi": [
+  "contract_name": "TokenTransferProxy",
+  "abi": [
+    {
+      "constant": false,
+      "inputs": [
         {
-            "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"
+          "name": "token",
+          "type": "address"
         },
         {
-            "constant": false,
-            "inputs": [
-                {
-                    "name": "target",
-                    "type": "address"
-                }
-            ],
-            "name": "addAuthorizedAddress",
-            "outputs": [],
-            "payable": false,
-            "type": "function"
+          "name": "from",
+          "type": "address"
         },
         {
-            "constant": true,
-            "inputs": [
-                {
-                    "name": "",
-                    "type": "uint256"
-                }
-            ],
-            "name": "authorities",
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "address"
-                }
-            ],
-            "payable": false,
-            "type": "function"
+          "name": "to",
+          "type": "address"
         },
         {
-            "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"
+          "name": "value",
+          "type": "uint256"
         }
-    ],
-    "networks": {
-        "1": {
-            "address": "0x8da0d80f5007ef1e431dd2127178d224e32c2ef4"
-        },
-        "3": {
-            "address": "0x4e9aad8184de8833365fea970cd9149372fdf1e6"
-        },
-        "4": {
-            "address": "0xa8e9fa8f91e5ae138c74648c9c304f1c75003a8d"
-        },
-        "42": {
-            "address": "0x087eed4bc1ee3de49befbd66c662b434b15d49d4"
-        },
-        "50": {
-            "address": "0x1dc4c1cefef38a777b15aa20260a54e584b16c48"
+      ],
+      "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"
     }
+  ],
+  "unlinked_binary": "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",
+  "networks": {},
+  "schema_version": "0.0.5",
+  "updated_at": 1503318938227
 }

packages/0x.js/src/artifacts/ZRX.json

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

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

@@ -0,0 +1,11 @@
+import BigNumber from 'bignumber.js';
+
+export const bigNumberConfigs = {
+    configure() {
+        // By default BigNumber's `toString` method converts to exponential notation if the value has
+        // more then 20 digits. We want to avoid this behavior, so we set EXPONENTIAL_AT to a high number
+        BigNumber.config({
+            EXPONENTIAL_AT: 1000,
+        });
+    },
+};

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

@@ -0,0 +1,80 @@
+import * as Web3 from 'web3';
+import * as _ from 'lodash';
+import promisify = require('es6-promisify');
+import {SchemaValidator, schemas} from '@0xproject/json-schemas';
+import {AbiType} from './types';
+
+export class Contract implements Web3.ContractInstance {
+    public address: string;
+    public abi: Web3.ContractAbi;
+    private contract: Web3.ContractInstance;
+    private defaults: Partial<Web3.TxData>;
+    private validator: SchemaValidator;
+    // This class instance is going to be populated with functions and events depending on the ABI
+    // and we don't know their types in advance
+    [name: string]: any;
+    constructor(web3ContractInstance: Web3.ContractInstance, defaults: Partial<Web3.TxData>) {
+        this.contract = web3ContractInstance;
+        this.address = web3ContractInstance.address;
+        this.abi = web3ContractInstance.abi;
+        this.defaults = defaults;
+        this.populateEvents();
+        this.populateFunctions();
+        this.validator = new SchemaValidator();
+    }
+    private populateFunctions(): void {
+        const functionsAbi = _.filter(this.abi, abiPart => abiPart.type === AbiType.Function);
+        _.forEach(functionsAbi, (functionAbi: Web3.MethodAbi) => {
+            if (functionAbi.constant) {
+                const cbStyleCallFunction = this.contract[functionAbi.name].call;
+                this[functionAbi.name] = {
+                    callAsync: promisify(cbStyleCallFunction, this.contract),
+                };
+            } else {
+                const cbStyleFunction = this.contract[functionAbi.name];
+                const cbStyleEstimateGasFunction = this.contract[functionAbi.name].estimateGas;
+                this[functionAbi.name] = {
+                    estimateGasAsync: promisify(cbStyleEstimateGasFunction, this.contract),
+                    sendTransactionAsync: this.promisifyWithDefaultParams(cbStyleFunction),
+                };
+            }
+        });
+    }
+    private populateEvents(): void {
+        const eventsAbi = _.filter(this.abi, abiPart => abiPart.type === AbiType.Event);
+        _.forEach(eventsAbi, (eventAbi: Web3.EventAbi) => {
+            this[eventAbi.name] = this.contract[eventAbi.name];
+        });
+    }
+    private promisifyWithDefaultParams(fn: (...args: any[]) => void): (...args: any[]) => Promise<any> {
+        const promisifiedWithDefaultParams = (...args: any[]) => {
+            const promise = new Promise((resolve, reject) => {
+                const lastArg = args[args.length - 1];
+                let txData: Partial<Web3.TxData> = {};
+                if (this.isTxData(lastArg)) {
+                    txData = args.pop();
+                }
+                txData = {
+                    ...this.defaults,
+                    ...txData,
+                };
+                const callback = (err: Error, data: any) => {
+                    if (_.isNull(err)) {
+                        resolve(data);
+                    } else {
+                        reject(err);
+                    }
+                };
+                args.push(txData);
+                args.push(callback);
+                fn.apply(this.contract, args);
+            });
+            return promise;
+        };
+        return promisifiedWithDefaultParams;
+    }
+    private isTxData(lastArg: any): boolean {
+        const isValid = this.validator.isValid(lastArg, schemas.txDataSchema);
+        return isValid;
+    }
+}

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

@@ -1,55 +1,47 @@
-import { 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 {BlockAndLogStreamer, Block} from 'ethereumjs-blockstream';
+import {Web3Wrapper} from '../web3_wrapper';
+import {AbiDecoder} from '../utils/abi_decoder';
 import {
-    Artifact,
-    BlockRange,
-    ContractEventArgs,
-    ContractEvents,
-    EventCallback,
-    IndexedFilterValues,
-    InternalZeroExError,
     ZeroExError,
+    InternalZeroExError,
+    Artifact,
+    LogWithDecodedArgs,
+    RawLog,
+    ContractEvents,
+    SubscriptionOpts,
+    IndexedFilterValues,
+    EventCallback,
+    BlockParamLiteral,
+    ContractEventArgs,
 } from '../types';
-import { constants } from '../utils/constants';
-import { filterUtils } from '../utils/filter_utils';
-
-const CONTRACT_NAME_TO_NOT_FOUND_ERROR: {
-    [contractName: string]: ZeroExError;
-} = {
-    ZRX: ZeroExError.ZRXContractDoesNotExist,
-    EtherToken: ZeroExError.EtherTokenContractDoesNotExist,
-    Token: ZeroExError.TokenContractDoesNotExist,
-    TokenRegistry: ZeroExError.TokenRegistryContractDoesNotExist,
-    TokenTransferProxy: ZeroExError.TokenTransferProxyContractDoesNotExist,
-    Exchange: ZeroExError.ExchangeContractDoesNotExist,
-};
+import {constants} from '../utils/constants';
+import {intervalUtils} from '../utils/interval_utils';
+import {filterUtils} from '../utils/filter_utils';
 
 export class ContractWrapper {
     protected _web3Wrapper: Web3Wrapper;
-    protected _networkId: number;
-    private _blockAndLogStreamerIfExists?: BlockAndLogStreamer;
-    private _blockAndLogStreamIntervalIfExists?: NodeJS.Timer;
-    private _filters: { [filterToken: string]: FilterObject };
-    private _filterCallbacks: {
-        [filterToken: string]: EventCallback<ContractEventArgs>;
-    };
-    private _onLogAddedSubscriptionToken: string | undefined;
-    private _onLogRemovedSubscriptionToken: string | undefined;
-    constructor(web3Wrapper: Web3Wrapper, networkId: number) {
+    private _abiDecoder?: AbiDecoder;
+    private _blockAndLogStreamer: BlockAndLogStreamer|undefined;
+    private _blockAndLogStreamInterval: NodeJS.Timer;
+    private _filters: {[filterToken: string]: Web3.FilterObject};
+    private _filterCallbacks: {[filterToken: string]: EventCallback<ContractEventArgs>};
+    private _onLogAddedSubscriptionToken: string|undefined;
+    private _onLogRemovedSubscriptionToken: string|undefined;
+    constructor(web3Wrapper: Web3Wrapper, abiDecoder?: AbiDecoder) {
         this._web3Wrapper = web3Wrapper;
-        this._networkId = networkId;
+        this._abiDecoder = abiDecoder;
         this._filters = {};
         this._filterCallbacks = {};
-        this._blockAndLogStreamerIfExists = undefined;
+        this._blockAndLogStreamer = undefined;
         this._onLogAddedSubscriptionToken = undefined;
         this._onLogRemovedSubscriptionToken = undefined;
     }
-    protected _unsubscribeAll(): void {
+    /**
+     * Cancels all existing subscriptions
+     */
+    public unsubscribeAll(): void {
         const filterTokens = _.keys(this._filterCallbacks);
         _.each(filterTokens, filterToken => {
             this._unsubscribe(filterToken);
@@ -70,133 +62,91 @@ export class ContractWrapper {
         }
     }
     protected _subscribe<ArgsType extends ContractEventArgs>(
-        address: string,
-        eventName: ContractEvents,
-        indexFilterValues: IndexedFilterValues,
-        abi: ContractAbi,
-        callback: EventCallback<ArgsType>,
-    ): string {
+        address: string, eventName: ContractEvents, indexFilterValues: IndexedFilterValues, abi: Web3.ContractAbi,
+        callback: EventCallback<ArgsType>): string {
         const filter = filterUtils.getFilter(address, eventName, indexFilterValues, abi);
-        if (_.isUndefined(this._blockAndLogStreamerIfExists)) {
+        if (_.isUndefined(this._blockAndLogStreamer)) {
             this._startBlockAndLogStream();
         }
         const filterToken = filterUtils.generateUUID();
         this._filters[filterToken] = filter;
-        this._filterCallbacks[filterToken] = callback as EventCallback<ContractEventArgs>;
+        this._filterCallbacks[filterToken] = callback;
         return filterToken;
     }
     protected async _getLogsAsync<ArgsType extends ContractEventArgs>(
-        address: string,
-        eventName: ContractEvents,
-        blockRange: BlockRange,
-        indexFilterValues: IndexedFilterValues,
-        abi: ContractAbi,
-    ): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
-        const filter = filterUtils.getFilter(address, eventName, indexFilterValues, abi, blockRange);
+        address: string, eventName: ContractEvents, subscriptionOpts: SubscriptionOpts,
+        indexFilterValues: IndexedFilterValues, abi: Web3.ContractAbi): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
+        const filter = filterUtils.getFilter(address, eventName, indexFilterValues, abi, subscriptionOpts);
         const logs = await this._web3Wrapper.getLogsAsync(filter);
         const logsWithDecodedArguments = _.map(logs, this._tryToDecodeLogOrNoop.bind(this));
         return logsWithDecodedArguments;
     }
     protected _tryToDecodeLogOrNoop<ArgsType extends ContractEventArgs>(
-        log: LogEntry,
-    ): LogWithDecodedArgs<ArgsType> | RawLog {
-        if (_.isUndefined(this._web3Wrapper.abiDecoder)) {
+        log: Web3.LogEntry): LogWithDecodedArgs<ArgsType>|RawLog {
+        if (_.isUndefined(this._abiDecoder)) {
             throw new Error(InternalZeroExError.NoAbiDecoder);
         }
-        const logWithDecodedArgs = this._web3Wrapper.abiDecoder.tryToDecodeLogOrNoop(log);
+        const logWithDecodedArgs = this._abiDecoder.tryToDecodeLogOrNoop(log);
         return logWithDecodedArgs;
     }
-    protected async _getContractAbiAndAddressFromArtifactsAsync(
-        artifact: Artifact,
-        addressIfExists?: string,
-    ): Promise<[ContractAbi, string]> {
-        let contractAddress: string;
-        if (_.isUndefined(addressIfExists)) {
-            if (_.isUndefined(artifact.networks[this._networkId])) {
-                throw new Error(ZeroExError.ContractNotDeployedOnNetwork);
-            }
-            contractAddress = artifact.networks[this._networkId].address.toLowerCase();
-        } else {
-            contractAddress = addressIfExists;
-        }
-        const doesContractExist = await this._web3Wrapper.doesContractExistAtAddressAsync(contractAddress);
-        if (!doesContractExist) {
-            throw new Error(CONTRACT_NAME_TO_NOT_FOUND_ERROR[artifact.contract_name]);
-        }
-        const abiAndAddress: [ContractAbi, string] = [artifact.abi, contractAddress];
-        return abiAndAddress;
+    protected async _instantiateContractIfExistsAsync<ContractType extends Web3.ContractInstance>(
+        artifact: Artifact, addressIfExists?: string): Promise<ContractType> {
+        const contractInstance =
+            await this._web3Wrapper.getContractInstanceFromArtifactAsync<ContractType>(artifact, addressIfExists);
+        return contractInstance;
     }
-    protected _getContractAddress(artifact: Artifact, addressIfExists?: string): string {
-        if (_.isUndefined(addressIfExists)) {
-            const contractAddress = artifact.networks[this._networkId].address;
-            if (_.isUndefined(contractAddress)) {
-                throw new Error(ZeroExError.ExchangeContractDoesNotExist);
-            }
-            return contractAddress;
-        } else {
-            return addressIfExists;
-        }
-    }
-    private _onLogStateChanged<ArgsType extends ContractEventArgs>(isRemoved: boolean, log: LogEntry): void {
-        _.forEach(this._filters, (filter: FilterObject, filterToken: string) => {
+    private _onLogStateChanged<ArgsType extends ContractEventArgs>(removed: boolean, log: Web3.LogEntry): void {
+        _.forEach(this._filters, (filter: Web3.FilterObject, filterToken: string) => {
             if (filterUtils.matchesFilter(log, filter)) {
                 const decodedLog = this._tryToDecodeLogOrNoop(log) as LogWithDecodedArgs<ArgsType>;
                 const logEvent = {
-                    log: decodedLog,
-                    isRemoved,
+                    ...decodedLog,
+                    removed,
                 };
                 this._filterCallbacks[filterToken](null, logEvent);
             }
         });
     }
     private _startBlockAndLogStream(): void {
-        if (!_.isUndefined(this._blockAndLogStreamerIfExists)) {
-            throw new Error(ZeroExError.SubscriptionAlreadyPresent);
-        }
-        this._blockAndLogStreamerIfExists = new BlockAndLogStreamer(
+        this._blockAndLogStreamer = new BlockAndLogStreamer(
             this._web3Wrapper.getBlockAsync.bind(this._web3Wrapper),
             this._web3Wrapper.getLogsAsync.bind(this._web3Wrapper),
         );
         const catchAllLogFilter = {};
-        this._blockAndLogStreamerIfExists.addLogFilter(catchAllLogFilter);
-        this._blockAndLogStreamIntervalIfExists = intervalUtils.setAsyncExcludingInterval(
-            this._reconcileBlockAsync.bind(this),
-            constants.DEFAULT_BLOCK_POLLING_INTERVAL,
-            this._onReconcileBlockError.bind(this),
+        this._blockAndLogStreamer.addLogFilter(catchAllLogFilter);
+        this._blockAndLogStreamInterval = intervalUtils.setAsyncExcludingInterval(
+            this._reconcileBlockAsync.bind(this), constants.DEFAULT_BLOCK_POLLING_INTERVAL,
         );
-        let isRemoved = false;
-        this._onLogAddedSubscriptionToken = this._blockAndLogStreamerIfExists.subscribeToOnLogAdded(
-            this._onLogStateChanged.bind(this, isRemoved),
+        let removed = false;
+        this._onLogAddedSubscriptionToken = this._blockAndLogStreamer.subscribeToOnLogAdded(
+            this._onLogStateChanged.bind(this, removed),
         );
-        isRemoved = true;
-        this._onLogRemovedSubscriptionToken = this._blockAndLogStreamerIfExists.subscribeToOnLogRemoved(
-            this._onLogStateChanged.bind(this, isRemoved),
+        removed = true;
+        this._onLogRemovedSubscriptionToken = this._blockAndLogStreamer.subscribeToOnLogRemoved(
+            this._onLogStateChanged.bind(this, removed),
         );
     }
-    private _onReconcileBlockError(err: Error): void {
-        const filterTokens = _.keys(this._filterCallbacks);
-        _.each(filterTokens, filterToken => {
-            this._unsubscribe(filterToken, err);
-        });
-    }
-    private _setNetworkId(networkId: number): void {
-        this._networkId = networkId;
-    }
     private _stopBlockAndLogStream(): void {
-        if (_.isUndefined(this._blockAndLogStreamerIfExists)) {
-            throw new Error(ZeroExError.SubscriptionNotFound);
-        }
-        this._blockAndLogStreamerIfExists.unsubscribeFromOnLogAdded(this._onLogAddedSubscriptionToken as string);
-        this._blockAndLogStreamerIfExists.unsubscribeFromOnLogRemoved(this._onLogRemovedSubscriptionToken as string);
-        intervalUtils.clearAsyncExcludingInterval(this._blockAndLogStreamIntervalIfExists as NodeJS.Timer);
-        delete this._blockAndLogStreamerIfExists;
+        (this._blockAndLogStreamer as BlockAndLogStreamer).unsubscribeFromOnLogAdded(
+            this._onLogAddedSubscriptionToken as string);
+        (this._blockAndLogStreamer as BlockAndLogStreamer).unsubscribeFromOnLogRemoved(
+            this._onLogRemovedSubscriptionToken as string);
+        intervalUtils.clearAsyncExcludingInterval(this._blockAndLogStreamInterval);
+        delete this._blockAndLogStreamer;
     }
     private async _reconcileBlockAsync(): Promise<void> {
-        const latestBlock = await this._web3Wrapper.getBlockAsync(BlockParamLiteral.Latest);
-        // We need to coerce to Block type cause Web3.Block includes types for mempool blocks
-        if (!_.isUndefined(this._blockAndLogStreamerIfExists)) {
-            // If we clear the interval while fetching the block - this._blockAndLogStreamer will be undefined
-            await this._blockAndLogStreamerIfExists.reconcileNewBlock((latestBlock as any) as Block);
+        try {
+            const latestBlock = await this._web3Wrapper.getBlockAsync(BlockParamLiteral.Latest);
+            // We need to coerce to Block type cause Web3.Block includes types for mempool blocks
+            if (!_.isUndefined(this._blockAndLogStreamer)) {
+                // If we clear the interval while fetching the block - this._blockAndLogStreamer will be undefined
+                this._blockAndLogStreamer.reconcileNewBlock(latestBlock as any as Block);
+            }
+        } catch (err) {
+            const filterTokens = _.keys(this._filterCallbacks);
+            _.each(filterTokens, filterToken => {
+                this._unsubscribe(filterToken, err);
+            });
         }
     }
 }

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

@@ -1,199 +1,87 @@
-import { schemas } from '@0xproject/json-schemas';
-import { LogWithDecodedArgs } from '@0xproject/types';
-import { AbiDecoder, BigNumber } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
-
-import { artifacts } from '../artifacts';
-import { BlockRange, EventCallback, IndexedFilterValues, TransactionOpts, ZeroExError } from '../types';
-import { assert } from '../utils/assert';
-
-import { ContractWrapper } from './contract_wrapper';
-import { EtherTokenContract, EtherTokenContractEventArgs, EtherTokenEvents } from './generated/ether_token';
-import { TokenWrapper } from './token_wrapper';
+import BigNumber from 'bignumber.js';
+import {Web3Wrapper} from '../web3_wrapper';
+import {ContractWrapper} from './contract_wrapper';
+import {TokenWrapper} from './token_wrapper';
+import {EtherTokenContract, ZeroExError} from '../types';
+import {assert} from '../utils/assert';
+import {artifacts} from '../artifacts';
 
 /**
  * This class includes all the functionality related to interacting with a wrapped Ether ERC20 token contract.
  * The caller can convert ETH into the equivalent number of wrapped ETH ERC20 tokens and back.
  */
 export class EtherTokenWrapper extends ContractWrapper {
-    private _etherTokenContractsByAddress: {
-        [address: string]: EtherTokenContract;
-    } = {};
+    private _etherTokenContractIfExists?: EtherTokenContract;
     private _tokenWrapper: TokenWrapper;
-    constructor(web3Wrapper: Web3Wrapper, networkId: number, tokenWrapper: TokenWrapper) {
-        super(web3Wrapper, networkId);
+    private _contractAddressIfExists?: string;
+    constructor(web3Wrapper: Web3Wrapper, tokenWrapper: TokenWrapper, contractAddressIfExists?: string) {
+        super(web3Wrapper);
         this._tokenWrapper = tokenWrapper;
+        this._contractAddressIfExists = contractAddressIfExists;
     }
     /**
      * Deposit ETH into the Wrapped ETH smart contract and issues the equivalent number of wrapped ETH tokens
      * to the depositor address. These wrapped ETH tokens can be used in 0x trades and are redeemable for 1-to-1
      * for ETH.
-     * @param   etherTokenAddress   EtherToken address you wish to deposit into.
-     * @param   amountInWei         Amount of ETH in Wei the caller wishes to deposit.
-     * @param   depositor           The hex encoded user Ethereum address that would like to make the deposit.
-     * @param   txOpts              Transaction parameters.
+     * @param   amountInWei      Amount of ETH in Wei the caller wishes to deposit.
+     * @param   depositor   The hex encoded user Ethereum address that would like to make the deposit.
      * @return Transaction hash.
      */
-    public async depositAsync(
-        etherTokenAddress: string,
-        amountInWei: BigNumber,
-        depositor: string,
-        txOpts: TransactionOpts = {},
-    ): Promise<string> {
-        assert.isETHAddressHex('etherTokenAddress', etherTokenAddress);
+    public async depositAsync(amountInWei: BigNumber, depositor: string): Promise<string> {
         assert.isValidBaseUnitAmount('amountInWei', amountInWei);
         await assert.isSenderAddressAsync('depositor', depositor, this._web3Wrapper);
-        const normalizedEtherTokenAddress = etherTokenAddress.toLowerCase();
-        const normalizedDepositorAddress = depositor.toLowerCase();
 
-        const ethBalanceInWei = await this._web3Wrapper.getBalanceInWeiAsync(normalizedDepositorAddress);
+        const ethBalanceInWei = await this._web3Wrapper.getBalanceInWeiAsync(depositor);
         assert.assert(ethBalanceInWei.gte(amountInWei), ZeroExError.InsufficientEthBalanceForDeposit);
 
-        const wethContract = await this._getEtherTokenContractAsync(normalizedEtherTokenAddress);
+        const wethContract = await this._getEtherTokenContractAsync();
         const txHash = await wethContract.deposit.sendTransactionAsync({
-            from: normalizedDepositorAddress,
+            from: depositor,
             value: amountInWei,
-            gas: txOpts.gasLimit,
-            gasPrice: txOpts.gasPrice,
         });
         return txHash;
     }
     /**
      * Withdraw ETH to the withdrawer's address from the wrapped ETH smart contract in exchange for the
      * equivalent number of wrapped ETH tokens.
-     * @param   etherTokenAddress   EtherToken address you wish to withdraw from.
      * @param   amountInWei  Amount of ETH in Wei the caller wishes to withdraw.
-     * @param   withdrawer   The hex encoded user Ethereum address that would like to make the withdrawal.
-     * @param   txOpts       Transaction parameters.
+     * @param   withdrawer   The hex encoded user Ethereum address that would like to make the withdrawl.
      * @return Transaction hash.
      */
-    public async withdrawAsync(
-        etherTokenAddress: string,
-        amountInWei: BigNumber,
-        withdrawer: string,
-        txOpts: TransactionOpts = {},
-    ): Promise<string> {
+    public async withdrawAsync(amountInWei: BigNumber, withdrawer: string): Promise<string> {
         assert.isValidBaseUnitAmount('amountInWei', amountInWei);
-        assert.isETHAddressHex('etherTokenAddress', etherTokenAddress);
         await assert.isSenderAddressAsync('withdrawer', withdrawer, this._web3Wrapper);
-        const normalizedEtherTokenAddress = etherTokenAddress.toLowerCase();
-        const normalizedWithdrawerAddress = withdrawer.toLowerCase();
 
-        const WETHBalanceInBaseUnits = await this._tokenWrapper.getBalanceAsync(
-            normalizedEtherTokenAddress,
-            normalizedWithdrawerAddress,
-        );
+        const wethContractAddress = await this.getContractAddressAsync();
+        const WETHBalanceInBaseUnits = await this._tokenWrapper.getBalanceAsync(wethContractAddress, withdrawer);
         assert.assert(WETHBalanceInBaseUnits.gte(amountInWei), ZeroExError.InsufficientWEthBalanceForWithdrawal);
 
-        const wethContract = await this._getEtherTokenContractAsync(normalizedEtherTokenAddress);
+        const wethContract = await this._getEtherTokenContractAsync();
         const txHash = await wethContract.withdraw.sendTransactionAsync(amountInWei, {
-            from: normalizedWithdrawerAddress,
-            gas: txOpts.gasLimit,
-            gasPrice: txOpts.gasPrice,
+            from: withdrawer,
         });
         return txHash;
     }
     /**
-     * Gets historical logs without creating a subscription
-     * @param   etherTokenAddress   An address of the ether token that emitted the logs.
-     * @param   eventName           The ether token contract event you would like to subscribe to.
-     * @param   blockRange          Block range to get logs from.
-     * @param   indexFilterValues   An object where the keys are indexed args returned by the event and
-     *                              the value is the value you are interested in. E.g `{_owner: aUserAddressHex}`
-     * @return  Array of logs that match the parameters
+     * Retrieves the Wrapped Ether token contract address
+     * @return  The Wrapped Ether token contract address
      */
-    public async getLogsAsync<ArgsType extends EtherTokenContractEventArgs>(
-        etherTokenAddress: string,
-        eventName: EtherTokenEvents,
-        blockRange: BlockRange,
-        indexFilterValues: IndexedFilterValues,
-    ): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
-        assert.isETHAddressHex('etherTokenAddress', etherTokenAddress);
-        const normalizedEtherTokenAddress = etherTokenAddress.toLowerCase();
-        assert.doesBelongToStringEnum('eventName', eventName, EtherTokenEvents);
-        assert.doesConformToSchema('blockRange', blockRange, schemas.blockRangeSchema);
-        assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
-        const logs = await this._getLogsAsync<ArgsType>(
-            normalizedEtherTokenAddress,
-            eventName,
-            blockRange,
-            indexFilterValues,
-            artifacts.EtherTokenArtifact.abi,
-        );
-        return logs;
-    }
-    /**
-     * Subscribe to an event type emitted by the Token contract.
-     * @param   etherTokenAddress   The hex encoded address where the ether token is deployed.
-     * @param   eventName           The ether token contract event you would like to subscribe to.
-     * @param   indexFilterValues   An object where the keys are indexed args returned by the event and
-     *                              the value is the value you are interested in. E.g `{_owner: aUserAddressHex}`
-     * @param   callback            Callback that gets called when a log is added/removed
-     * @return Subscription token used later to unsubscribe
-     */
-    public subscribe<ArgsType extends EtherTokenContractEventArgs>(
-        etherTokenAddress: string,
-        eventName: EtherTokenEvents,
-        indexFilterValues: IndexedFilterValues,
-        callback: EventCallback<ArgsType>,
-    ): string {
-        assert.isETHAddressHex('etherTokenAddress', etherTokenAddress);
-        const normalizedEtherTokenAddress = etherTokenAddress.toLowerCase();
-        assert.doesBelongToStringEnum('eventName', eventName, EtherTokenEvents);
-        assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
-        assert.isFunction('callback', callback);
-        const subscriptionToken = this._subscribe<ArgsType>(
-            normalizedEtherTokenAddress,
-            eventName,
-            indexFilterValues,
-            artifacts.EtherTokenArtifact.abi,
-            callback,
-        );
-        return subscriptionToken;
-    }
-    /**
-     * Cancel a subscription
-     * @param   subscriptionToken Subscription token returned by `subscribe()`
-     */
-    public unsubscribe(subscriptionToken: string): void {
-        this._unsubscribe(subscriptionToken);
-    }
-    /**
-     * Cancels all existing subscriptions
-     */
-    public unsubscribeAll(): void {
-        super._unsubscribeAll();
-    }
-    /**
-     * Retrieves the Ethereum address of the EtherToken contract deployed on the network
-     * that the user-passed web3 provider is connected to. If it's not Kovan, Ropsten, Rinkeby, Mainnet or TestRPC
-     * (networkId: 50), it will return undefined (e.g a private network).
-     * @returns The Ethereum address of the EtherToken contract or undefined.
-     */
-    public getContractAddressIfExists(): string | undefined {
-        const networkSpecificArtifact = artifacts.EtherTokenArtifact.networks[this._networkId];
-        const contractAddressIfExists = _.isUndefined(networkSpecificArtifact)
-            ? undefined
-            : networkSpecificArtifact.address;
-        return contractAddressIfExists;
+    public async getContractAddressAsync(): Promise<string> {
+        const wethContract = await this._getEtherTokenContractAsync();
+        return wethContract.address;
     }
     private _invalidateContractInstance(): void {
-        this.unsubscribeAll();
-        this._etherTokenContractsByAddress = {};
+        delete this._etherTokenContractIfExists;
     }
-    private async _getEtherTokenContractAsync(etherTokenAddress: string): Promise<EtherTokenContract> {
-        let etherTokenContract = this._etherTokenContractsByAddress[etherTokenAddress];
-        if (!_.isUndefined(etherTokenContract)) {
-            return etherTokenContract;
+    private async _getEtherTokenContractAsync(): Promise<EtherTokenContract> {
+        if (!_.isUndefined(this._etherTokenContractIfExists)) {
+            return this._etherTokenContractIfExists;
         }
-        const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
-            artifacts.EtherTokenArtifact,
-            etherTokenAddress,
+        const contractInstance = await this._instantiateContractIfExistsAsync<EtherTokenContract>(
+            artifacts.EtherTokenArtifact, this._contractAddressIfExists,
         );
-        const contractInstance = new EtherTokenContract(this._web3Wrapper, abi, address);
-        etherTokenContract = contractInstance;
-        this._etherTokenContractsByAddress[etherTokenAddress] = etherTokenContract;
-        return etherTokenContract;
+        this._etherTokenContractIfExists = contractInstance as EtherTokenContract;
+        return this._etherTokenContractIfExists;
     }
 }

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

@@ -1,46 +1,44 @@
-import { schemas } from '@0xproject/json-schemas';
-import {
-    BlockParamLiteral,
-    DecodedLogArgs,
-    ECSignature,
-    LogEntry,
-    LogWithDecodedArgs,
-    Order,
-    SignedOrder,
-} from '@0xproject/types';
-import { AbiDecoder, BigNumber } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
-
-import { artifacts } from '../artifacts';
+import * as Web3 from 'web3';
+import BigNumber from 'bignumber.js';
+import {schemas} from '@0xproject/json-schemas';
+import {Web3Wrapper} from '../web3_wrapper';
 import {
-    BlockRange,
-    EventCallback,
+    ECSignature,
+    ExchangeContract,
     ExchangeContractErrCodes,
     ExchangeContractErrs,
-    IndexedFilterValues,
-    MethodOpts,
+    ZeroExError,
+    OrderValues,
     OrderAddresses,
+    Order,
+    SignedOrder,
+    ExchangeEvents,
+    SubscriptionOpts,
+    IndexedFilterValues,
     OrderCancellationRequest,
     OrderFillRequest,
-    OrderTransactionOpts,
-    OrderValues,
-    ValidateOrderFillableOpts,
-} from '../types';
-import { assert } from '../utils/assert';
-import { decorators } from '../utils/decorators';
-import { ExchangeTransferSimulator } from '../utils/exchange_transfer_simulator';
-import { OrderValidationUtils } from '../utils/order_validation_utils';
-import { utils } from '../utils/utils';
-
-import { ContractWrapper } from './contract_wrapper';
-import {
-    ExchangeContract,
-    ExchangeContractEventArgs,
-    ExchangeEvents,
     LogErrorContractEventArgs,
-} from './generated/exchange';
-import { TokenWrapper } from './token_wrapper';
+    LogFillContractEventArgs,
+    LogCancelContractEventArgs,
+    LogWithDecodedArgs,
+    MethodOpts,
+    ValidateOrderFillableOpts,
+    OrderTransactionOpts,
+    RawLog,
+    EventCallback,
+    ExchangeContractEventArgs,
+    DecodedLogArgs,
+} from '../types';
+import {assert} from '../utils/assert';
+import {utils} from '../utils/utils';
+import {OrderValidationUtils} from '../utils/order_validation_utils';
+import {ContractWrapper} from './contract_wrapper';
+import {TokenWrapper} from './token_wrapper';
+import {decorators} from '../utils/decorators';
+import {AbiDecoder} from '../utils/abi_decoder';
+import {ExchangeTransferSimulator} from '../utils/exchange_transfer_simulator';
+import {artifacts} from '../artifacts';
 
 const SHOULD_VALIDATE_BY_DEFAULT = true;
 
@@ -65,7 +63,6 @@ export class ExchangeWrapper extends ContractWrapper {
         [ExchangeContractErrCodes.ERROR_FILL_BALANCE_ALLOWANCE]: ExchangeContractErrs.FillBalanceAllowanceError,
     };
     private _contractAddressIfExists?: string;
-    private _zrxContractAddressIfExists?: string;
     private static _getOrderAddressesAndValues(order: Order): [OrderAddresses, OrderValues] {
         const orderAddresses: OrderAddresses = [
             order.maker,
@@ -84,18 +81,12 @@ export class ExchangeWrapper extends ContractWrapper {
         ];
         return [orderAddresses, orderValues];
     }
-    constructor(
-        web3Wrapper: Web3Wrapper,
-        networkId: number,
-        tokenWrapper: TokenWrapper,
-        contractAddressIfExists?: string,
-        zrxContractAddressIfExists?: string,
-    ) {
-        super(web3Wrapper, networkId);
+    constructor(web3Wrapper: Web3Wrapper, abiDecoder: AbiDecoder,
+                tokenWrapper: TokenWrapper, contractAddressIfExists?: string) {
+        super(web3Wrapper, abiDecoder);
         this._tokenWrapper = tokenWrapper;
-        this._orderValidationUtils = new OrderValidationUtils(this);
+        this._orderValidationUtils = new OrderValidationUtils(tokenWrapper, this);
         this._contractAddressIfExists = contractAddressIfExists;
-        this._zrxContractAddressIfExists = zrxContractAddressIfExists;
     }
     /**
      * Returns the unavailable takerAmount of an order. Unavailable amount is defined as the total
@@ -106,16 +97,14 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   methodOpts              Optional arguments this method accepts.
      * @return  The amount of the order (in taker tokens) that has either been filled or cancelled.
      */
-    public async getUnavailableTakerAmountAsync(orderHash: string, methodOpts?: MethodOpts): Promise<BigNumber> {
+    public async getUnavailableTakerAmountAsync(orderHash: string,
+                                                methodOpts?: MethodOpts): Promise<BigNumber> {
         assert.doesConformToSchema('orderHash', orderHash, schemas.orderHashSchema);
 
         const exchangeContract = await this._getExchangeContractAsync();
         const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
-        const txData = {};
         let unavailableTakerTokenAmount = await exchangeContract.getUnavailableTakerTokenAmount.callAsync(
-            orderHash,
-            txData,
-            defaultBlock,
+            orderHash, defaultBlock,
         );
         // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
         unavailableTakerTokenAmount = new BigNumber(unavailableTakerTokenAmount);
@@ -132,8 +121,7 @@ export class ExchangeWrapper extends ContractWrapper {
 
         const exchangeContract = await this._getExchangeContractAsync();
         const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
-        const txData = {};
-        let fillAmountInBaseUnits = await exchangeContract.filled.callAsync(orderHash, txData, defaultBlock);
+        let fillAmountInBaseUnits = await exchangeContract.filled.callAsync(orderHash, defaultBlock);
         // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
         fillAmountInBaseUnits = new BigNumber(fillAmountInBaseUnits);
         return fillAmountInBaseUnits;
@@ -150,8 +138,7 @@ export class ExchangeWrapper extends ContractWrapper {
 
         const exchangeContract = await this._getExchangeContractAsync();
         const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
-        const txData = {};
-        let cancelledAmountInBaseUnits = await exchangeContract.cancelled.callAsync(orderHash, txData, defaultBlock);
+        let cancelledAmountInBaseUnits = await exchangeContract.cancelled.callAsync(orderHash, defaultBlock);
         // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
         cancelledAmountInBaseUnits = new BigNumber(cancelledAmountInBaseUnits);
         return cancelledAmountInBaseUnits;
@@ -175,38 +162,41 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   orderTransactionOpts                        Optional arguments this method accepts.
      * @return  Transaction hash.
      */
-    @decorators.asyncZeroExErrorHandler
-    public async fillOrderAsync(
-        signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber,
-        shouldThrowOnInsufficientBalanceOrAllowance: boolean,
-        takerAddress: string,
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
+    @decorators.contractCallErrorHandler
+    public async fillOrderAsync(signedOrder: SignedOrder, fillTakerTokenAmount: BigNumber,
+                                shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+                                takerAddress: string,
+                                orderTransactionOpts?: OrderTransactionOpts): Promise<string> {
         assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
         assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
         assert.isBoolean('shouldThrowOnInsufficientBalanceOrAllowance', shouldThrowOnInsufficientBalanceOrAllowance);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-        const normalizedTakerAddress = takerAddress.toLowerCase();
 
         const exchangeInstance = await this._getExchangeContractAsync();
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
+        const shouldValidate = _.isUndefined(orderTransactionOpts) ?
+            SHOULD_VALIDATE_BY_DEFAULT :
+            orderTransactionOpts.shouldValidate;
         if (shouldValidate) {
-            const zrxTokenAddress = this.getZRXTokenAddress();
-            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+            const zrxTokenAddress = await this.getZRXTokenAddressAsync();
+            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper);
             await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
-                exchangeTradeEmulator,
-                signedOrder,
-                fillTakerTokenAmount,
-                normalizedTakerAddress,
-                zrxTokenAddress,
-            );
+                exchangeTradeEmulator, signedOrder, fillTakerTokenAmount, takerAddress, zrxTokenAddress);
         }
 
         const [orderAddresses, orderValues] = ExchangeWrapper._getOrderAddressesAndValues(signedOrder);
 
+        const gas = await exchangeInstance.fillOrder.estimateGasAsync(
+            orderAddresses,
+            orderValues,
+            fillTakerTokenAmount,
+            shouldThrowOnInsufficientBalanceOrAllowance,
+            signedOrder.ecSignature.v,
+            signedOrder.ecSignature.r,
+            signedOrder.ecSignature.s,
+            {
+                from: takerAddress,
+            },
+        );
         const txHash: string = await exchangeInstance.fillOrder.sendTransactionAsync(
             orderAddresses,
             orderValues,
@@ -216,9 +206,8 @@ export class ExchangeWrapper extends ContractWrapper {
             signedOrder.ecSignature.r,
             signedOrder.ecSignature.s,
             {
-                from: normalizedTakerAddress,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
+                from: takerAddress,
+                gas,
             },
         );
         return txHash;
@@ -240,49 +229,31 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   orderTransactionOpts                        Optional arguments this method accepts.
      * @return  Transaction hash.
      */
-    @decorators.asyncZeroExErrorHandler
-    public async fillOrdersUpToAsync(
-        signedOrders: SignedOrder[],
-        fillTakerTokenAmount: BigNumber,
-        shouldThrowOnInsufficientBalanceOrAllowance: boolean,
-        takerAddress: string,
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
+    @decorators.contractCallErrorHandler
+    public async fillOrdersUpToAsync(signedOrders: SignedOrder[], fillTakerTokenAmount: BigNumber,
+                                     shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+                                     takerAddress: string,
+                                     orderTransactionOpts?: OrderTransactionOpts): Promise<string> {
         assert.doesConformToSchema('signedOrders', signedOrders, schemas.signedOrdersSchema);
         const takerTokenAddresses = _.map(signedOrders, signedOrder => signedOrder.takerTokenAddress);
-        assert.hasAtMostOneUniqueValue(
-            takerTokenAddresses,
-            ExchangeContractErrs.MultipleTakerTokensInFillUpToDisallowed,
-        );
+        assert.hasAtMostOneUniqueValue(takerTokenAddresses,
+                                       ExchangeContractErrs.MultipleTakerTokensInFillUpToDisallowed);
         const exchangeContractAddresses = _.map(signedOrders, signedOrder => signedOrder.exchangeContractAddress);
-        assert.hasAtMostOneUniqueValue(
-            exchangeContractAddresses,
-            ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
-        );
+        assert.hasAtMostOneUniqueValue(exchangeContractAddresses,
+                                       ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress);
         assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
         assert.isBoolean('shouldThrowOnInsufficientBalanceOrAllowance', shouldThrowOnInsufficientBalanceOrAllowance);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-        const normalizedTakerAddress = takerAddress.toLowerCase();
 
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
+        const shouldValidate = _.isUndefined(orderTransactionOpts) ?
+            SHOULD_VALIDATE_BY_DEFAULT :
+            orderTransactionOpts.shouldValidate;
         if (shouldValidate) {
-            let filledTakerTokenAmount = new BigNumber(0);
-            const zrxTokenAddress = this.getZRXTokenAddress();
-            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+            const zrxTokenAddress = await this.getZRXTokenAddressAsync();
+            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper);
             for (const signedOrder of signedOrders) {
-                const singleFilledTakerTokenAmount = await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
-                    exchangeTradeEmulator,
-                    signedOrder,
-                    fillTakerTokenAmount.minus(filledTakerTokenAmount),
-                    normalizedTakerAddress,
-                    zrxTokenAddress,
-                );
-                filledTakerTokenAmount = filledTakerTokenAmount.plus(singleFilledTakerTokenAmount);
-                if (filledTakerTokenAmount.eq(fillTakerTokenAmount)) {
-                    break;
-                }
+                await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
+                    exchangeTradeEmulator, signedOrder, fillTakerTokenAmount, takerAddress, zrxTokenAddress);
             }
         }
 
@@ -304,6 +275,18 @@ export class ExchangeWrapper extends ContractWrapper {
         );
 
         const exchangeInstance = await this._getExchangeContractAsync();
+        const gas = await exchangeInstance.fillOrdersUpTo.estimateGasAsync(
+            orderAddressesArray,
+            orderValuesArray,
+            fillTakerTokenAmount,
+            shouldThrowOnInsufficientBalanceOrAllowance,
+            vArray,
+            rArray,
+            sArray,
+            {
+                from: takerAddress,
+            },
+        );
         const txHash = await exchangeInstance.fillOrdersUpTo.sendTransactionAsync(
             orderAddressesArray,
             orderValuesArray,
@@ -313,9 +296,8 @@ export class ExchangeWrapper extends ContractWrapper {
             rArray,
             sArray,
             {
-                from: normalizedTakerAddress,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
+                from: takerAddress,
+                gas,
             },
         );
         return txHash;
@@ -339,38 +321,30 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   orderTransactionOpts                            Optional arguments this method accepts.
      * @return  Transaction hash.
      */
-    @decorators.asyncZeroExErrorHandler
-    public async batchFillOrdersAsync(
-        orderFillRequests: OrderFillRequest[],
-        shouldThrowOnInsufficientBalanceOrAllowance: boolean,
-        takerAddress: string,
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
+    @decorators.contractCallErrorHandler
+    public async batchFillOrdersAsync(orderFillRequests: OrderFillRequest[],
+                                      shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+                                      takerAddress: string,
+                                      orderTransactionOpts?: OrderTransactionOpts): Promise<string> {
         assert.doesConformToSchema('orderFillRequests', orderFillRequests, schemas.orderFillRequestsSchema);
         const exchangeContractAddresses = _.map(
             orderFillRequests,
             orderFillRequest => orderFillRequest.signedOrder.exchangeContractAddress,
         );
-        assert.hasAtMostOneUniqueValue(
-            exchangeContractAddresses,
-            ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
-        );
+        assert.hasAtMostOneUniqueValue(exchangeContractAddresses,
+                                       ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress);
         assert.isBoolean('shouldThrowOnInsufficientBalanceOrAllowance', shouldThrowOnInsufficientBalanceOrAllowance);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-        const normalizedTakerAddress = takerAddress.toLowerCase();
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
+        const shouldValidate = _.isUndefined(orderTransactionOpts) ?
+            SHOULD_VALIDATE_BY_DEFAULT :
+            orderTransactionOpts.shouldValidate;
         if (shouldValidate) {
-            const zrxTokenAddress = this.getZRXTokenAddress();
-            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+            const zrxTokenAddress = await this.getZRXTokenAddressAsync();
+            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper);
             for (const orderFillRequest of orderFillRequests) {
                 await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
-                    exchangeTradeEmulator,
-                    orderFillRequest.signedOrder,
-                    orderFillRequest.takerTokenFillAmount,
-                    normalizedTakerAddress,
-                    zrxTokenAddress,
+                    exchangeTradeEmulator, orderFillRequest.signedOrder, orderFillRequest.takerTokenFillAmount,
+                    takerAddress, zrxTokenAddress,
                 );
             }
         }
@@ -393,6 +367,18 @@ export class ExchangeWrapper extends ContractWrapper {
         );
 
         const exchangeInstance = await this._getExchangeContractAsync();
+        const gas = await exchangeInstance.batchFillOrders.estimateGasAsync(
+            orderAddressesArray,
+            orderValuesArray,
+            fillTakerTokenAmounts,
+            shouldThrowOnInsufficientBalanceOrAllowance,
+            vArray,
+            rArray,
+            sArray,
+            {
+                from: takerAddress,
+            },
+        );
         const txHash = await exchangeInstance.batchFillOrders.sendTransactionAsync(
             orderAddressesArray,
             orderValuesArray,
@@ -402,9 +388,8 @@ export class ExchangeWrapper extends ContractWrapper {
             rArray,
             sArray,
             {
-                from: normalizedTakerAddress,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
+                from: takerAddress,
+                gas,
             },
         );
         return txHash;
@@ -420,36 +405,39 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   orderTransactionOpts    Optional arguments this method accepts.
      * @return  Transaction hash.
      */
-    @decorators.asyncZeroExErrorHandler
-    public async fillOrKillOrderAsync(
-        signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber,
-        takerAddress: string,
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
+    @decorators.contractCallErrorHandler
+    public async fillOrKillOrderAsync(signedOrder: SignedOrder, fillTakerTokenAmount: BigNumber,
+                                      takerAddress: string,
+                                      orderTransactionOpts?: OrderTransactionOpts): Promise<string> {
         assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
         assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-        const normalizedTakerAddress = takerAddress.toLowerCase();
 
         const exchangeInstance = await this._getExchangeContractAsync();
 
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
+        const shouldValidate = _.isUndefined(orderTransactionOpts) ?
+            SHOULD_VALIDATE_BY_DEFAULT :
+            orderTransactionOpts.shouldValidate;
         if (shouldValidate) {
-            const zrxTokenAddress = this.getZRXTokenAddress();
-            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+            const zrxTokenAddress = await this.getZRXTokenAddressAsync();
+            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper);
             await this._orderValidationUtils.validateFillOrKillOrderThrowIfInvalidAsync(
-                exchangeTradeEmulator,
-                signedOrder,
-                fillTakerTokenAmount,
-                normalizedTakerAddress,
-                zrxTokenAddress,
-            );
+                exchangeTradeEmulator, signedOrder, fillTakerTokenAmount, takerAddress, zrxTokenAddress);
         }
 
         const [orderAddresses, orderValues] = ExchangeWrapper._getOrderAddressesAndValues(signedOrder);
+
+        const gas = await exchangeInstance.fillOrKillOrder.estimateGasAsync(
+            orderAddresses,
+            orderValues,
+            fillTakerTokenAmount,
+            signedOrder.ecSignature.v,
+            signedOrder.ecSignature.r,
+            signedOrder.ecSignature.s,
+            {
+                from: takerAddress,
+            },
+        );
         const txHash = await exchangeInstance.fillOrKillOrder.sendTransactionAsync(
             orderAddresses,
             orderValues,
@@ -458,9 +446,8 @@ export class ExchangeWrapper extends ContractWrapper {
             signedOrder.ecSignature.r,
             signedOrder.ecSignature.s,
             {
-                from: normalizedTakerAddress,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
+                from: takerAddress,
+                gas,
             },
         );
         return txHash;
@@ -474,41 +461,34 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   orderTransactionOpts        Optional arguments this method accepts.
      * @return  Transaction hash.
      */
-    @decorators.asyncZeroExErrorHandler
-    public async batchFillOrKillAsync(
-        orderFillRequests: OrderFillRequest[],
-        takerAddress: string,
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
-        assert.doesConformToSchema('orderFillRequests', orderFillRequests, schemas.orderFillRequestsSchema);
+    @decorators.contractCallErrorHandler
+    public async batchFillOrKillAsync(orderFillRequests: OrderFillRequest[],
+                                      takerAddress: string,
+                                      orderTransactionOpts?: OrderTransactionOpts): Promise<string> {
+        assert.doesConformToSchema('orderFillRequests', orderFillRequests,
+                                   schemas.orderFillRequestsSchema);
         const exchangeContractAddresses = _.map(
             orderFillRequests,
             orderFillRequest => orderFillRequest.signedOrder.exchangeContractAddress,
         );
-        assert.hasAtMostOneUniqueValue(
-            exchangeContractAddresses,
-            ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
-        );
+        assert.hasAtMostOneUniqueValue(exchangeContractAddresses,
+                                       ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-        const normalizedTakerAddress = takerAddress.toLowerCase();
         if (_.isEmpty(orderFillRequests)) {
             throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
         }
         const exchangeInstance = await this._getExchangeContractAsync();
 
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
+        const shouldValidate = _.isUndefined(orderTransactionOpts) ?
+            SHOULD_VALIDATE_BY_DEFAULT :
+            orderTransactionOpts.shouldValidate;
         if (shouldValidate) {
-            const zrxTokenAddress = this.getZRXTokenAddress();
-            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+            const zrxTokenAddress = await this.getZRXTokenAddressAsync();
+            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper);
             for (const orderFillRequest of orderFillRequests) {
                 await this._orderValidationUtils.validateFillOrKillOrderThrowIfInvalidAsync(
-                    exchangeTradeEmulator,
-                    orderFillRequest.signedOrder,
-                    orderFillRequest.takerTokenFillAmount,
-                    normalizedTakerAddress,
-                    zrxTokenAddress,
+                    exchangeTradeEmulator, orderFillRequest.signedOrder, orderFillRequest.takerTokenFillAmount,
+                    takerAddress, zrxTokenAddress,
                 );
             }
         }
@@ -524,8 +504,19 @@ export class ExchangeWrapper extends ContractWrapper {
         });
 
         // We use _.unzip<any> because _.unzip doesn't type check if values have different types :'(
-        const [orderAddresses, orderValues, fillTakerTokenAmounts, vParams, rParams, sParams] = _.unzip<any>(
-            orderAddressesValuesAndTakerTokenFillAmounts,
+        const [orderAddresses, orderValues, fillTakerTokenAmounts, vParams, rParams, sParams] =
+              _.unzip<any>(orderAddressesValuesAndTakerTokenFillAmounts);
+
+        const gas = await exchangeInstance.batchFillOrKillOrders.estimateGasAsync(
+            orderAddresses,
+            orderValues,
+            fillTakerTokenAmounts,
+            vParams,
+            rParams,
+            sParams,
+            {
+                from: takerAddress,
+            },
         );
         const txHash = await exchangeInstance.batchFillOrKillOrders.sendTransactionAsync(
             orderAddresses,
@@ -535,9 +526,8 @@ export class ExchangeWrapper extends ContractWrapper {
             rParams,
             sParams,
             {
-                from: normalizedTakerAddress,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
+                from: takerAddress,
+                gas,
             },
         );
         return txHash;
@@ -550,41 +540,42 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   transactionOpts         Optional arguments this method accepts.
      * @return  Transaction hash.
      */
-    @decorators.asyncZeroExErrorHandler
-    public async cancelOrderAsync(
-        order: Order | SignedOrder,
-        cancelTakerTokenAmount: BigNumber,
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
+    @decorators.contractCallErrorHandler
+    public async cancelOrderAsync(order: Order|SignedOrder,
+                                  cancelTakerTokenAmount: BigNumber,
+                                  orderTransactionOpts?: OrderTransactionOpts): Promise<string> {
         assert.doesConformToSchema('order', order, schemas.orderSchema);
         assert.isValidBaseUnitAmount('takerTokenCancelAmount', cancelTakerTokenAmount);
         await assert.isSenderAddressAsync('order.maker', order.maker, this._web3Wrapper);
-        const normalizedMakerAddress = order.maker.toLowerCase();
 
         const exchangeInstance = await this._getExchangeContractAsync();
 
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
+        const shouldValidate = _.isUndefined(orderTransactionOpts) ?
+            SHOULD_VALIDATE_BY_DEFAULT :
+            orderTransactionOpts.shouldValidate;
         if (shouldValidate) {
             const orderHash = utils.getOrderHashHex(order);
             const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
-            OrderValidationUtils.validateCancelOrderThrowIfInvalid(
-                order,
-                cancelTakerTokenAmount,
-                unavailableTakerTokenAmount,
-            );
+            await this._orderValidationUtils.validateCancelOrderThrowIfInvalidAsync(
+                order, cancelTakerTokenAmount, unavailableTakerTokenAmount);
         }
 
         const [orderAddresses, orderValues] = ExchangeWrapper._getOrderAddressesAndValues(order);
+        const gas = await exchangeInstance.cancelOrder.estimateGasAsync(
+            orderAddresses,
+            orderValues,
+            cancelTakerTokenAmount,
+            {
+                from: order.maker,
+            },
+        );
         const txHash = await exchangeInstance.cancelOrder.sendTransactionAsync(
             orderAddresses,
             orderValues,
             cancelTakerTokenAmount,
             {
-                from: normalizedMakerAddress,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
+                from: order.maker,
+                gas,
             },
         );
         return txHash;
@@ -597,43 +588,34 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   transactionOpts             Optional arguments this method accepts.
      * @return  Transaction hash.
      */
-    @decorators.asyncZeroExErrorHandler
-    public async batchCancelOrdersAsync(
-        orderCancellationRequests: OrderCancellationRequest[],
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
-        assert.doesConformToSchema(
-            'orderCancellationRequests',
-            orderCancellationRequests,
-            schemas.orderCancellationRequestsSchema,
-        );
+    @decorators.contractCallErrorHandler
+    public async batchCancelOrdersAsync(orderCancellationRequests: OrderCancellationRequest[],
+                                        orderTransactionOpts?: OrderTransactionOpts): Promise<string> {
+        assert.doesConformToSchema('orderCancellationRequests', orderCancellationRequests,
+                                   schemas.orderCancellationRequestsSchema);
         const exchangeContractAddresses = _.map(
             orderCancellationRequests,
             orderCancellationRequest => orderCancellationRequest.order.exchangeContractAddress,
         );
-        assert.hasAtMostOneUniqueValue(
-            exchangeContractAddresses,
-            ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
-        );
+        assert.hasAtMostOneUniqueValue(exchangeContractAddresses,
+                                       ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress);
         const makers = _.map(orderCancellationRequests, cancellationRequest => cancellationRequest.order.maker);
         assert.hasAtMostOneUniqueValue(makers, ExchangeContractErrs.MultipleMakersInSingleCancelBatchDisallowed);
         const maker = makers[0];
         await assert.isSenderAddressAsync('maker', maker, this._web3Wrapper);
-        const normalizedMakerAddress = maker.toLowerCase();
-
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
+        const shouldValidate = _.isUndefined(orderTransactionOpts) ?
+            SHOULD_VALIDATE_BY_DEFAULT :
+            orderTransactionOpts.shouldValidate;
         if (shouldValidate) {
             for (const orderCancellationRequest of orderCancellationRequests) {
                 const orderHash = utils.getOrderHashHex(orderCancellationRequest.order);
                 const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
-                OrderValidationUtils.validateCancelOrderThrowIfInvalid(
-                    orderCancellationRequest.order,
-                    orderCancellationRequest.takerTokenCancelAmount,
+                await this._orderValidationUtils.validateCancelOrderThrowIfInvalidAsync(
+                    orderCancellationRequest.order, orderCancellationRequest.takerTokenCancelAmount,
                     unavailableTakerTokenAmount,
                 );
             }
+
         }
         if (_.isEmpty(orderCancellationRequests)) {
             throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
@@ -646,17 +628,23 @@ export class ExchangeWrapper extends ContractWrapper {
             ];
         });
         // We use _.unzip<any> because _.unzip doesn't type check if values have different types :'(
-        const [orderAddresses, orderValues, cancelTakerTokenAmounts] = _.unzip<any>(
-            orderAddressesValuesAndTakerTokenCancelAmounts,
+        const [orderAddresses, orderValues, cancelTakerTokenAmounts] =
+            _.unzip<any>(orderAddressesValuesAndTakerTokenCancelAmounts);
+        const gas = await exchangeInstance.batchCancelOrders.estimateGasAsync(
+            orderAddresses,
+            orderValues,
+            cancelTakerTokenAmounts,
+            {
+                from: maker,
+            },
         );
         const txHash = await exchangeInstance.batchCancelOrders.sendTransactionAsync(
             orderAddresses,
             orderValues,
             cancelTakerTokenAmounts,
             {
-                from: normalizedMakerAddress,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
+                from: maker,
+                gas,
             },
         );
         return txHash;
@@ -669,21 +657,15 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   callback            Callback that gets called when a log is added/removed
      * @return Subscription token used later to unsubscribe
      */
-    public subscribe<ArgsType extends ExchangeContractEventArgs>(
-        eventName: ExchangeEvents,
-        indexFilterValues: IndexedFilterValues,
-        callback: EventCallback<ArgsType>,
-    ): string {
+    public async subscribeAsync<ArgsType extends ExchangeContractEventArgs>(
+        eventName: ExchangeEvents, indexFilterValues: IndexedFilterValues,
+        callback: EventCallback<ArgsType>): Promise<string> {
         assert.doesBelongToStringEnum('eventName', eventName, ExchangeEvents);
         assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
         assert.isFunction('callback', callback);
-        const exchangeContractAddress = this.getContractAddress();
+        const exchangeContractAddress = await this.getContractAddressAsync();
         const subscriptionToken = this._subscribe<ArgsType>(
-            exchangeContractAddress,
-            eventName,
-            indexFilterValues,
-            artifacts.ExchangeArtifact.abi,
-            callback,
+            exchangeContractAddress, eventName, indexFilterValues, artifacts.ExchangeArtifact.abi, callback,
         );
         return subscriptionToken;
     }
@@ -694,35 +676,23 @@ export class ExchangeWrapper extends ContractWrapper {
     public unsubscribe(subscriptionToken: string): void {
         this._unsubscribe(subscriptionToken);
     }
-    /**
-     * Cancels all existing subscriptions
-     */
-    public unsubscribeAll(): void {
-        super._unsubscribeAll();
-    }
     /**
      * Gets historical logs without creating a subscription
      * @param   eventName           The exchange contract event you would like to subscribe to.
-     * @param   blockRange          Block range to get logs from.
+     * @param   subscriptionOpts    Subscriptions options that let you configure the subscription.
      * @param   indexFilterValues   An object where the keys are indexed args returned by the event and
      *                              the value is the value you are interested in. E.g `{_from: aUserAddressHex}`
      * @return  Array of logs that match the parameters
      */
     public async getLogsAsync<ArgsType extends ExchangeContractEventArgs>(
-        eventName: ExchangeEvents,
-        blockRange: BlockRange,
-        indexFilterValues: IndexedFilterValues,
+        eventName: ExchangeEvents, subscriptionOpts: SubscriptionOpts, indexFilterValues: IndexedFilterValues,
     ): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
         assert.doesBelongToStringEnum('eventName', eventName, ExchangeEvents);
-        assert.doesConformToSchema('blockRange', blockRange, schemas.blockRangeSchema);
+        assert.doesConformToSchema('subscriptionOpts', subscriptionOpts, schemas.subscriptionOptsSchema);
         assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
-        const exchangeContractAddress = this.getContractAddress();
+        const exchangeContractAddress = await this.getContractAddressAsync();
         const logs = await this._getLogsAsync<ArgsType>(
-            exchangeContractAddress,
-            eventName,
-            blockRange,
-            indexFilterValues,
-            artifacts.ExchangeArtifact.abi,
+            exchangeContractAddress, eventName, subscriptionOpts, indexFilterValues, artifacts.ExchangeArtifact.abi,
         );
         return logs;
     }
@@ -731,9 +701,10 @@ export class ExchangeWrapper extends ContractWrapper {
      * that the user-passed web3 provider is connected to.
      * @returns The Ethereum address of the Exchange contract being used.
      */
-    public getContractAddress(): string {
-        const contractAddress = this._getContractAddress(artifacts.ExchangeArtifact, this._contractAddressIfExists);
-        return contractAddress;
+    public async getContractAddressAsync(): Promise<string> {
+        const exchangeInstance = await this._getExchangeContractAsync();
+        const exchangeAddress = exchangeInstance.address;
+        return exchangeAddress;
     }
     /**
      * Checks if order is still fillable and throws an error otherwise. Useful for orderbook
@@ -745,18 +716,14 @@ export class ExchangeWrapper extends ContractWrapper {
      *                          to validate for.
      */
     public async validateOrderFillableOrThrowAsync(
-        signedOrder: SignedOrder,
-        opts?: ValidateOrderFillableOpts,
+        signedOrder: SignedOrder, opts?: ValidateOrderFillableOpts,
     ): Promise<void> {
         assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
-        const zrxTokenAddress = this.getZRXTokenAddress();
+        const zrxTokenAddress = await this.getZRXTokenAddressAsync();
         const expectedFillTakerTokenAmount = !_.isUndefined(opts) ? opts.expectedFillTakerTokenAmount : undefined;
-        const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+        const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper);
         await this._orderValidationUtils.validateOrderFillableOrThrowAsync(
-            exchangeTradeEmulator,
-            signedOrder,
-            zrxTokenAddress,
-            expectedFillTakerTokenAmount,
+            exchangeTradeEmulator, signedOrder, zrxTokenAddress, expectedFillTakerTokenAmount,
         );
     }
     /**
@@ -767,24 +734,16 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   takerAddress            The user Ethereum address who would like to fill this order.
      *                                  Must be available via the supplied Web3.Provider passed to 0x.js.
      */
-    public async validateFillOrderThrowIfInvalidAsync(
-        signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber,
-        takerAddress: string,
-    ): Promise<void> {
+    public async validateFillOrderThrowIfInvalidAsync(signedOrder: SignedOrder,
+                                                      fillTakerTokenAmount: BigNumber,
+                                                      takerAddress: string): Promise<void> {
         assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
         assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-        const normalizedTakerAddress = takerAddress.toLowerCase();
-        const zrxTokenAddress = this.getZRXTokenAddress();
-        const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+        const zrxTokenAddress = await this.getZRXTokenAddressAsync();
+        const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper);
         await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
-            exchangeTradeEmulator,
-            signedOrder,
-            fillTakerTokenAmount,
-            normalizedTakerAddress,
-            zrxTokenAddress,
-        );
+            exchangeTradeEmulator, signedOrder, fillTakerTokenAmount, takerAddress, zrxTokenAddress);
     }
     /**
      * Checks if cancelling a given order will succeed and throws an informative error if it won't.
@@ -793,18 +752,13 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   cancelTakerTokenAmount  The amount (specified in taker tokens) that you would like to cancel.
      */
     public async validateCancelOrderThrowIfInvalidAsync(
-        order: Order,
-        cancelTakerTokenAmount: BigNumber,
-    ): Promise<void> {
+        order: Order, cancelTakerTokenAmount: BigNumber): Promise<void> {
         assert.doesConformToSchema('order', order, schemas.orderSchema);
         assert.isValidBaseUnitAmount('cancelTakerTokenAmount', cancelTakerTokenAmount);
         const orderHash = utils.getOrderHashHex(order);
         const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
-        OrderValidationUtils.validateCancelOrderThrowIfInvalid(
-            order,
-            cancelTakerTokenAmount,
-            unavailableTakerTokenAmount,
-        );
+        await this._orderValidationUtils.validateCancelOrderThrowIfInvalidAsync(
+            order, cancelTakerTokenAmount, unavailableTakerTokenAmount);
     }
     /**
      * Checks if calling fillOrKill on a given order will succeed and throws an informative error if it won't.
@@ -814,24 +768,16 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   takerAddress            The user Ethereum address who would like to fill this order.
      *                                  Must be available via the supplied Web3.Provider passed to 0x.js.
      */
-    public async validateFillOrKillOrderThrowIfInvalidAsync(
-        signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber,
-        takerAddress: string,
-    ): Promise<void> {
+    public async validateFillOrKillOrderThrowIfInvalidAsync(signedOrder: SignedOrder,
+                                                            fillTakerTokenAmount: BigNumber,
+                                                            takerAddress: string): Promise<void> {
         assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
         assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-        const normalizedTakerAddress = takerAddress.toLowerCase();
-        const zrxTokenAddress = this.getZRXTokenAddress();
-        const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+        const zrxTokenAddress = await this.getZRXTokenAddressAsync();
+        const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper);
         await this._orderValidationUtils.validateFillOrKillOrderThrowIfInvalidAsync(
-            exchangeTradeEmulator,
-            signedOrder,
-            fillTakerTokenAmount,
-            normalizedTakerAddress,
-            zrxTokenAddress,
-        );
+            exchangeTradeEmulator, signedOrder, fillTakerTokenAmount, takerAddress, zrxTokenAddress);
     }
     /**
      * Checks if rounding error will be > 0.1% when computing makerTokenAmount by doing:
@@ -842,33 +788,29 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   takerTokenAmount       The order size on the taker side
      * @param   makerTokenAmount       The order size on the maker side
      */
-    public async isRoundingErrorAsync(
-        fillTakerTokenAmount: BigNumber,
-        takerTokenAmount: BigNumber,
-        makerTokenAmount: BigNumber,
-    ): Promise<boolean> {
+    public async isRoundingErrorAsync(fillTakerTokenAmount: BigNumber,
+                                      takerTokenAmount: BigNumber,
+                                      makerTokenAmount: BigNumber): Promise<boolean> {
         assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
         assert.isValidBaseUnitAmount('takerTokenAmount', takerTokenAmount);
         assert.isValidBaseUnitAmount('makerTokenAmount', makerTokenAmount);
         const exchangeInstance = await this._getExchangeContractAsync();
         const isRoundingError = await exchangeInstance.isRoundingError.callAsync(
-            fillTakerTokenAmount,
-            takerTokenAmount,
-            makerTokenAmount,
+            fillTakerTokenAmount, takerTokenAmount, makerTokenAmount,
         );
         return isRoundingError;
     }
     /**
-     * Checks if logs contain LogError, which is emitted by Exchange contract on transaction failure.
+     * Checks if logs contain LogError, which is emmited by Exchange contract on transaction failure.
      * @param   logs   Transaction logs as returned by `zeroEx.awaitTransactionMinedAsync`
      */
-    public throwLogErrorsAsErrors(logs: Array<LogWithDecodedArgs<DecodedLogArgs> | LogEntry>): void {
+    public throwLogErrorsAsErrors(logs: Array<LogWithDecodedArgs<DecodedLogArgs>|Web3.LogEntry>): void {
         const errLog = _.find(logs, {
             event: ExchangeEvents.LogError,
-        });
+        }) as LogWithDecodedArgs<LogErrorContractEventArgs>|undefined;
         if (!_.isUndefined(errLog)) {
-            const logArgs = (errLog as LogWithDecodedArgs<LogErrorContractEventArgs>).args;
-            const errCode = logArgs.errorId;
+            const logArgs = errLog.args;
+            const errCode = logArgs.errorId.toNumber();
             const errMessage = this._exchangeContractErrCodesToMsg[errCode];
             throw new Error(errMessage);
         }
@@ -877,28 +819,25 @@ export class ExchangeWrapper extends ContractWrapper {
      * Returns the ZRX token address used by the exchange contract.
      * @return Address of ZRX token
      */
-    public getZRXTokenAddress(): string {
-        const contractAddress = this._getContractAddress(artifacts.ZRXArtifact, this._zrxContractAddressIfExists);
-        return contractAddress;
+    public async getZRXTokenAddressAsync(): Promise<string> {
+        const exchangeInstance = await this._getExchangeContractAsync();
+        const ZRXtokenAddress = await exchangeInstance.ZRX_TOKEN_CONTRACT.callAsync();
+        return ZRXtokenAddress;
     }
-    private _invalidateContractInstances(): void {
+    private async _invalidateContractInstancesAsync(): Promise<void> {
         this.unsubscribeAll();
         delete this._exchangeContractIfExists;
     }
-    private async _isValidSignatureUsingContractCallAsync(
-        dataHex: string,
-        ecSignature: ECSignature,
-        signerAddressHex: string,
-    ): Promise<boolean> {
+    private async _isValidSignatureUsingContractCallAsync(dataHex: string, ecSignature: ECSignature,
+                                                          signerAddressHex: string): Promise<boolean> {
         assert.isHexString('dataHex', dataHex);
         assert.doesConformToSchema('ecSignature', ecSignature, schemas.ecSignatureSchema);
         assert.isETHAddressHex('signerAddressHex', signerAddressHex);
-        const normalizedSignerAddress = signerAddressHex.toLowerCase();
 
         const exchangeInstance = await this._getExchangeContractAsync();
 
         const isValidSignature = await exchangeInstance.isValidSignature.callAsync(
-            normalizedSignerAddress,
+            signerAddressHex,
             dataHex,
             ecSignature.v,
             ecSignature.r,
@@ -906,7 +845,7 @@ export class ExchangeWrapper extends ContractWrapper {
         );
         return isValidSignature;
     }
-    private async _getOrderHashHexUsingContractCallAsync(order: Order | SignedOrder): Promise<string> {
+    private async _getOrderHashHexUsingContractCallAsync(order: Order|SignedOrder): Promise<string> {
         const exchangeInstance = await this._getExchangeContractAsync();
         const [orderAddresses, orderValues] = ExchangeWrapper._getOrderAddressesAndValues(order);
         const orderHashHex = await exchangeInstance.getOrderHash.callAsync(orderAddresses, orderValues);
@@ -916,12 +855,10 @@ export class ExchangeWrapper extends ContractWrapper {
         if (!_.isUndefined(this._exchangeContractIfExists)) {
             return this._exchangeContractIfExists;
         }
-        const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
-            artifacts.ExchangeArtifact,
-            this._contractAddressIfExists,
+        const contractInstance = await this._instantiateContractIfExistsAsync<ExchangeContract>(
+            artifacts.ExchangeArtifact, this._contractAddressIfExists,
         );
-        const contractInstance = new ExchangeContract(this._web3Wrapper, abi, address);
-        this._exchangeContractIfExists = contractInstance;
+        this._exchangeContractIfExists = contractInstance as ExchangeContract;
         return this._exchangeContractIfExists;
     }
     private async _getTokenTransferProxyAddressAsync(): Promise<string> {
@@ -930,4 +867,4 @@ export class ExchangeWrapper extends ContractWrapper {
         const tokenTransferProxyAddressLowerCase = tokenTransferProxyAddress.toLowerCase();
         return tokenTransferProxyAddressLowerCase;
     }
-} // tslint:disable:max-file-line-count
+}

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

@@ -1,13 +1,10 @@
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
-
-import { artifacts } from '../artifacts';
-import { Token, TokenMetadata } from '../types';
-import { assert } from '../utils/assert';
-import { constants } from '../utils/constants';
-
-import { ContractWrapper } from './contract_wrapper';
-import { TokenRegistryContract } from './generated/token_registry';
+import {Web3Wrapper} from '../web3_wrapper';
+import {assert} from '../utils/assert';
+import {Token, TokenRegistryContract, TokenMetadata} from '../types';
+import {constants} from '../utils/constants';
+import {ContractWrapper} from './contract_wrapper';
+import {artifacts} from '../artifacts';
 
 /**
  * This class includes all the functionality related to interacting with the 0x Token Registry smart contract.
@@ -15,20 +12,8 @@ import { TokenRegistryContract } from './generated/token_registry';
 export class TokenRegistryWrapper extends ContractWrapper {
     private _tokenRegistryContractIfExists?: TokenRegistryContract;
     private _contractAddressIfExists?: string;
-    private static _createTokenFromMetadata(metadata: TokenMetadata): Token | undefined {
-        if (metadata[0] === constants.NULL_ADDRESS) {
-            return undefined;
-        }
-        const token = {
-            address: metadata[0],
-            name: metadata[1],
-            symbol: metadata[2],
-            decimals: metadata[3],
-        };
-        return token;
-    }
-    constructor(web3Wrapper: Web3Wrapper, networkId: number, contractAddressIfExists?: string) {
-        super(web3Wrapper, networkId);
+    constructor(web3Wrapper: Web3Wrapper, contractAddressIfExists?: string) {
+        super(web3Wrapper);
         this._contractAddressIfExists = contractAddressIfExists;
     }
     /**
@@ -36,9 +21,12 @@ export class TokenRegistryWrapper extends ContractWrapper {
      * @return  An array of objects that conform to the Token interface.
      */
     public async getTokensAsync(): Promise<Token[]> {
+        const tokenRegistryContract = await this._getTokenRegistryContractAsync();
+
         const addresses = await this.getTokenAddressesAsync();
-        const tokenPromises: Array<Promise<Token | undefined>> = _.map(addresses, async (address: string) =>
-            this.getTokenIfExistsAsync(address),
+        const tokenPromises: Array<Promise<Token|undefined>> = _.map(
+            addresses,
+            (address: string) => (this.getTokenIfExistsAsync(address)),
         );
         const tokens = await Promise.all(tokenPromises);
         return tokens as Token[];
@@ -50,23 +38,21 @@ export class TokenRegistryWrapper extends ContractWrapper {
     public async getTokenAddressesAsync(): Promise<string[]> {
         const tokenRegistryContract = await this._getTokenRegistryContractAsync();
         const addresses = await tokenRegistryContract.getTokenAddresses.callAsync();
-        const lowerCaseAddresses = _.map(addresses, address => address.toLowerCase());
-        return lowerCaseAddresses;
+        return addresses;
     }
     /**
      * Retrieves a token by address currently listed in the Token Registry smart contract
      * @return  An object that conforms to the Token interface or undefined if token not found.
      */
-    public async getTokenIfExistsAsync(address: string): Promise<Token | undefined> {
+    public async getTokenIfExistsAsync(address: string): Promise<Token|undefined> {
         assert.isETHAddressHex('address', address);
-        const normalizedAddress = address.toLowerCase();
 
         const tokenRegistryContract = await this._getTokenRegistryContractAsync();
-        const metadata = await tokenRegistryContract.getTokenMetaData.callAsync(normalizedAddress);
-        const token = TokenRegistryWrapper._createTokenFromMetadata(metadata);
+        const metadata = await tokenRegistryContract.getTokenMetaData.callAsync(address);
+        const token = this._createTokenFromMetadata(metadata);
         return token;
     }
-    public async getTokenAddressBySymbolIfExistsAsync(symbol: string): Promise<string | undefined> {
+    public async getTokenAddressBySymbolIfExistsAsync(symbol: string): Promise<string|undefined> {
         assert.isString('symbol', symbol);
         const tokenRegistryContract = await this._getTokenRegistryContractAsync();
         const addressIfExists = await tokenRegistryContract.getTokenAddressBySymbol.callAsync(symbol);
@@ -75,7 +61,7 @@ export class TokenRegistryWrapper extends ContractWrapper {
         }
         return addressIfExists;
     }
-    public async getTokenAddressByNameIfExistsAsync(name: string): Promise<string | undefined> {
+    public async getTokenAddressByNameIfExistsAsync(name: string): Promise<string|undefined> {
         assert.isString('name', name);
         const tokenRegistryContract = await this._getTokenRegistryContractAsync();
         const addressIfExists = await tokenRegistryContract.getTokenAddressByName.callAsync(name);
@@ -84,18 +70,18 @@ export class TokenRegistryWrapper extends ContractWrapper {
         }
         return addressIfExists;
     }
-    public async getTokenBySymbolIfExistsAsync(symbol: string): Promise<Token | undefined> {
+    public async getTokenBySymbolIfExistsAsync(symbol: string): Promise<Token|undefined> {
         assert.isString('symbol', symbol);
         const tokenRegistryContract = await this._getTokenRegistryContractAsync();
         const metadata = await tokenRegistryContract.getTokenBySymbol.callAsync(symbol);
-        const token = TokenRegistryWrapper._createTokenFromMetadata(metadata);
+        const token = this._createTokenFromMetadata(metadata);
         return token;
     }
-    public async getTokenByNameIfExistsAsync(name: string): Promise<Token | undefined> {
+    public async getTokenByNameIfExistsAsync(name: string): Promise<Token|undefined> {
         assert.isString('name', name);
         const tokenRegistryContract = await this._getTokenRegistryContractAsync();
         const metadata = await tokenRegistryContract.getTokenByName.callAsync(name);
-        const token = TokenRegistryWrapper._createTokenFromMetadata(metadata);
+        const token = this._createTokenFromMetadata(metadata);
         return token;
     }
     /**
@@ -103,12 +89,22 @@ export class TokenRegistryWrapper extends ContractWrapper {
      * that the user-passed web3 provider is connected to.
      * @returns The Ethereum address of the TokenRegistry contract being used.
      */
-    public getContractAddress(): string {
-        const contractAddress = this._getContractAddress(
-            artifacts.TokenRegistryArtifact,
-            this._contractAddressIfExists,
-        );
-        return contractAddress;
+    public async getContractAddressAsync(): Promise<string> {
+        const tokenRegistryInstance = await this._getTokenRegistryContractAsync();
+        const tokenRegistryAddress = tokenRegistryInstance.address;
+        return tokenRegistryAddress;
+    }
+    private _createTokenFromMetadata(metadata: TokenMetadata): Token|undefined {
+        if (metadata[0] === constants.NULL_ADDRESS) {
+            return undefined;
+        }
+        const token = {
+            address: metadata[0],
+            name: metadata[1],
+            symbol: metadata[2],
+            decimals: metadata[3].toNumber(),
+        };
+        return token;
     }
     private _invalidateContractInstance(): void {
         delete this._tokenRegistryContractIfExists;
@@ -117,12 +113,10 @@ export class TokenRegistryWrapper extends ContractWrapper {
         if (!_.isUndefined(this._tokenRegistryContractIfExists)) {
             return this._tokenRegistryContractIfExists;
         }
-        const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
-            artifacts.TokenRegistryArtifact,
-            this._contractAddressIfExists,
+        const contractInstance = await this._instantiateContractIfExistsAsync<TokenRegistryContract>(
+            artifacts.TokenRegistryArtifact, this._contractAddressIfExists,
         );
-        const contractInstance = new TokenRegistryContract(this._web3Wrapper, abi, address);
-        this._tokenRegistryContractIfExists = contractInstance;
+        this._tokenRegistryContractIfExists = contractInstance as TokenRegistryContract;
         return this._tokenRegistryContractIfExists;
     }
 }

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

@@ -1,21 +1,18 @@
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
-
-import { artifacts } from '../artifacts';
-import { assert } from '../utils/assert';
-
-import { ContractWrapper } from './contract_wrapper';
-import { TokenTransferProxyContract } from './generated/token_transfer_proxy';
+import {Web3Wrapper} from '../web3_wrapper';
+import {ContractWrapper} from './contract_wrapper';
+import {artifacts} from '../artifacts';
+import {TokenTransferProxyContract} from '../types';
 
 /**
  * This class includes the functionality related to interacting with the TokenTransferProxy contract.
  */
 export class TokenTransferProxyWrapper extends ContractWrapper {
     private _tokenTransferProxyContractIfExists?: TokenTransferProxyContract;
-    private _contractAddressIfExists?: string;
-    constructor(web3Wrapper: Web3Wrapper, networkId: number, contractAddressIfExists?: string) {
-        super(web3Wrapper, networkId);
-        this._contractAddressIfExists = contractAddressIfExists;
+    private _tokenTransferProxyContractAddressFetcher: () => Promise<string>;
+    constructor(web3Wrapper: Web3Wrapper, tokenTransferProxyContractAddressFetcher: () => Promise<string>) {
+        super(web3Wrapper);
+        this._tokenTransferProxyContractAddressFetcher = tokenTransferProxyContractAddressFetcher;
     }
     /**
      * Check if the Exchange contract address is authorized by the TokenTransferProxy contract.
@@ -23,12 +20,8 @@ export class TokenTransferProxyWrapper extends ContractWrapper {
      * @return  Whether the exchangeContractAddress is authorized.
      */
     public async isAuthorizedAsync(exchangeContractAddress: string): Promise<boolean> {
-        assert.isETHAddressHex('exchangeContractAddress', exchangeContractAddress);
-        const normalizedExchangeContractAddress = exchangeContractAddress.toLowerCase();
         const tokenTransferProxyContractInstance = await this._getTokenTransferProxyContractAsync();
-        const isAuthorized = await tokenTransferProxyContractInstance.authorized.callAsync(
-            normalizedExchangeContractAddress,
-        );
+        const isAuthorized = await tokenTransferProxyContractInstance.authorized.callAsync(exchangeContractAddress);
         return isAuthorized;
     }
     /**
@@ -45,12 +38,10 @@ export class TokenTransferProxyWrapper extends ContractWrapper {
      * that the user-passed web3 provider is connected to.
      * @returns The Ethereum address of the TokenTransferProxy contract being used.
      */
-    public getContractAddress(): string {
-        const contractAddress = this._getContractAddress(
-            artifacts.TokenTransferProxyArtifact,
-            this._contractAddressIfExists,
-        );
-        return contractAddress;
+    public async getContractAddressAsync(): Promise<string> {
+        const proxyInstance = await this._getTokenTransferProxyContractAsync();
+        const proxyAddress = proxyInstance.address;
+        return proxyAddress;
     }
     private _invalidateContractInstance(): void {
         delete this._tokenTransferProxyContractIfExists;
@@ -59,12 +50,11 @@ export class TokenTransferProxyWrapper extends ContractWrapper {
         if (!_.isUndefined(this._tokenTransferProxyContractIfExists)) {
             return this._tokenTransferProxyContractIfExists;
         }
-        const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
-            artifacts.TokenTransferProxyArtifact,
-            this._contractAddressIfExists,
+        const contractAddress = await this._tokenTransferProxyContractAddressFetcher();
+        const contractInstance = await this._instantiateContractIfExistsAsync<TokenTransferProxyContract>(
+            artifacts.TokenTransferProxyArtifact, contractAddress,
         );
-        const contractInstance = new TokenTransferProxyContract(this._web3Wrapper, abi, address);
-        this._tokenTransferProxyContractIfExists = contractInstance;
+        this._tokenTransferProxyContractIfExists = contractInstance as TokenTransferProxyContract;
         return this._tokenTransferProxyContractIfExists;
     }
 }

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

@@ -1,17 +1,25 @@
-import { schemas } from '@0xproject/json-schemas';
-import { LogWithDecodedArgs } from '@0xproject/types';
-import { AbiDecoder, BigNumber } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
+import BigNumber from 'bignumber.js';
+import {schemas} from '@0xproject/json-schemas';
+import {Web3Wrapper} from '../web3_wrapper';
+import {assert} from '../utils/assert';
+import {constants} from '../utils/constants';
+import {ContractWrapper} from './contract_wrapper';
+import {AbiDecoder} from '../utils/abi_decoder';
+import {artifacts} from '../artifacts';
+import {
+    TokenContract,
+    ZeroExError,
+    TokenEvents,
+    IndexedFilterValues,
+    SubscriptionOpts,
+    MethodOpts,
+    LogWithDecodedArgs,
+    EventCallback,
+    TokenContractEventArgs,
+} from '../types';
 
-import { artifacts } from '../artifacts';
-import { BlockRange, EventCallback, IndexedFilterValues, MethodOpts, TransactionOpts, ZeroExError } from '../types';
-import { assert } from '../utils/assert';
-import { constants } from '../utils/constants';
-
-import { ContractWrapper } from './contract_wrapper';
-import { TokenContract, TokenContractEventArgs, TokenEvents } from './generated/token';
-import { TokenTransferProxyWrapper } from './token_transfer_proxy_wrapper';
+const ALLOWANCE_TO_ZERO_GAS_AMOUNT = 47275;
 
 /**
  * This class includes all the functionality related to interacting with ERC20 token contracts.
@@ -20,12 +28,13 @@ import { TokenTransferProxyWrapper } from './token_transfer_proxy_wrapper';
  */
 export class TokenWrapper extends ContractWrapper {
     public UNLIMITED_ALLOWANCE_IN_BASE_UNITS = constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
-    private _tokenContractsByAddress: { [address: string]: TokenContract };
-    private _tokenTransferProxyWrapper: TokenTransferProxyWrapper;
-    constructor(web3Wrapper: Web3Wrapper, networkId: number, tokenTransferProxyWrapper: TokenTransferProxyWrapper) {
-        super(web3Wrapper, networkId);
+    private _tokenContractsByAddress: {[address: string]: TokenContract};
+    private _tokenTransferProxyContractAddressFetcher: () => Promise<string>;
+    constructor(web3Wrapper: Web3Wrapper, abiDecoder: AbiDecoder,
+                tokenTransferProxyContractAddressFetcher: () => Promise<string>) {
+        super(web3Wrapper, abiDecoder);
         this._tokenContractsByAddress = {};
-        this._tokenTransferProxyWrapper = tokenTransferProxyWrapper;
+        this._tokenTransferProxyContractAddressFetcher = tokenTransferProxyContractAddressFetcher;
     }
     /**
      * Retrieves an owner's ERC20 token balance.
@@ -34,20 +43,14 @@ export class TokenWrapper extends ContractWrapper {
      * @param   methodOpts      Optional arguments this method accepts.
      * @return  The owner's ERC20 token balance in base units.
      */
-    public async getBalanceAsync(
-        tokenAddress: string,
-        ownerAddress: string,
-        methodOpts?: MethodOpts,
-    ): Promise<BigNumber> {
+    public async getBalanceAsync(tokenAddress: string, ownerAddress: string,
+                                 methodOpts?: MethodOpts): Promise<BigNumber> {
         assert.isETHAddressHex('ownerAddress', ownerAddress);
         assert.isETHAddressHex('tokenAddress', tokenAddress);
-        const normalizedTokenAddress = tokenAddress.toLowerCase();
-        const normalizedOwnerAddress = ownerAddress.toLowerCase();
 
-        const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
+        const tokenContract = await this._getTokenContractAsync(tokenAddress);
         const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
-        const txData = {};
-        let balance = await tokenContract.balanceOf.callAsync(normalizedOwnerAddress, txData, defaultBlock);
+        let balance = await tokenContract.balanceOf.callAsync(ownerAddress, defaultBlock);
         // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
         balance = new BigNumber(balance);
         return balance;
@@ -60,29 +63,24 @@ export class TokenWrapper extends ContractWrapper {
      *                              for spenderAddress.
      * @param   spenderAddress      The hex encoded user Ethereum address who will be able to spend the set allowance.
      * @param   amountInBaseUnits   The allowance amount you would like to set.
-     * @param   txOpts              Transaction parameters.
      * @return Transaction hash.
      */
-    public async setAllowanceAsync(
-        tokenAddress: string,
-        ownerAddress: string,
-        spenderAddress: string,
-        amountInBaseUnits: BigNumber,
-        txOpts: TransactionOpts = {},
-    ): Promise<string> {
+    public async setAllowanceAsync(tokenAddress: string, ownerAddress: string, spenderAddress: string,
+                                   amountInBaseUnits: BigNumber): Promise<string> {
+        await assert.isSenderAddressAsync('ownerAddress', ownerAddress, this._web3Wrapper);
         assert.isETHAddressHex('spenderAddress', spenderAddress);
         assert.isETHAddressHex('tokenAddress', tokenAddress);
-        await assert.isSenderAddressAsync('ownerAddress', ownerAddress, this._web3Wrapper);
-        const normalizedTokenAddress = tokenAddress.toLowerCase();
-        const normalizedSpenderAddress = spenderAddress.toLowerCase();
-        const normalizedOwnerAddress = ownerAddress.toLowerCase();
         assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
 
-        const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
-        const txHash = await tokenContract.approve.sendTransactionAsync(normalizedSpenderAddress, amountInBaseUnits, {
-            from: normalizedOwnerAddress,
-            gas: txOpts.gasLimit,
-            gasPrice: txOpts.gasPrice,
+        const tokenContract = await this._getTokenContractAsync(tokenAddress);
+        // Hack: for some reason default estimated gas amount causes `base fee exceeds gas limit` exception
+        // on testrpc. Probably related to https://github.com/ethereumjs/testrpc/issues/294
+        // TODO: Debug issue in testrpc and submit a PR, then remove this hack
+        const networkIdIfExists = await this._web3Wrapper.getNetworkIdIfExistsAsync();
+        const gas = networkIdIfExists === constants.TESTRPC_NETWORK_ID ? ALLOWANCE_TO_ZERO_GAS_AMOUNT : undefined;
+        const txHash = await tokenContract.approve.sendTransactionAsync(spenderAddress, amountInBaseUnits, {
+            from: ownerAddress,
+            gas,
         });
         return txHash;
     }
@@ -95,27 +93,12 @@ export class TokenWrapper extends ContractWrapper {
      * @param   ownerAddress        The hex encoded user Ethereum address who would like to set an allowance
      *                              for spenderAddress.
      * @param   spenderAddress      The hex encoded user Ethereum address who will be able to spend the set allowance.
-     * @param   txOpts              Transaction parameters.
      * @return Transaction hash.
      */
-    public async setUnlimitedAllowanceAsync(
-        tokenAddress: string,
-        ownerAddress: string,
-        spenderAddress: string,
-        txOpts: TransactionOpts = {},
-    ): Promise<string> {
-        assert.isETHAddressHex('ownerAddress', ownerAddress);
-        assert.isETHAddressHex('tokenAddress', tokenAddress);
-        assert.isETHAddressHex('spenderAddress', spenderAddress);
-        const normalizedTokenAddress = tokenAddress.toLowerCase();
-        const normalizedOwnerAddress = ownerAddress.toLowerCase();
-        const normalizedSpenderAddress = spenderAddress.toLowerCase();
+    public async setUnlimitedAllowanceAsync(tokenAddress: string, ownerAddress: string,
+                                            spenderAddress: string): Promise<string> {
         const txHash = await this.setAllowanceAsync(
-            normalizedTokenAddress,
-            normalizedOwnerAddress,
-            normalizedSpenderAddress,
-            this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS,
-            txOpts,
+            tokenAddress, ownerAddress, spenderAddress, this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS,
         );
         return txHash;
     }
@@ -127,28 +110,14 @@ export class TokenWrapper extends ContractWrapper {
      * @param   spenderAddress  The hex encoded user Ethereum address who can spend the allowance you are fetching.
      * @param   methodOpts      Optional arguments this method accepts.
      */
-    public async getAllowanceAsync(
-        tokenAddress: string,
-        ownerAddress: string,
-        spenderAddress: string,
-        methodOpts?: MethodOpts,
-    ): Promise<BigNumber> {
+    public async getAllowanceAsync(tokenAddress: string, ownerAddress: string,
+                                   spenderAddress: string, methodOpts?: MethodOpts): Promise<BigNumber> {
         assert.isETHAddressHex('ownerAddress', ownerAddress);
         assert.isETHAddressHex('tokenAddress', tokenAddress);
-        assert.isETHAddressHex('spenderAddress', spenderAddress);
-        const normalizedTokenAddress = tokenAddress.toLowerCase();
-        const normalizedOwnerAddress = ownerAddress.toLowerCase();
-        const normalizedSpenderAddress = spenderAddress.toLowerCase();
 
-        const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
+        const tokenContract = await this._getTokenContractAsync(tokenAddress);
         const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
-        const txData = {};
-        let allowanceInBaseUnits = await tokenContract.allowance.callAsync(
-            normalizedOwnerAddress,
-            normalizedSpenderAddress,
-            txData,
-            defaultBlock,
-        );
+        let allowanceInBaseUnits = await tokenContract.allowance.callAsync(ownerAddress, spenderAddress, defaultBlock);
         // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
         allowanceInBaseUnits = new BigNumber(allowanceInBaseUnits);
         return allowanceInBaseUnits;
@@ -159,23 +128,13 @@ export class TokenWrapper extends ContractWrapper {
      * @param   ownerAddress    The hex encoded user Ethereum address whose proxy contract allowance we are retrieving.
      * @param   methodOpts      Optional arguments this method accepts.
      */
-    public async getProxyAllowanceAsync(
-        tokenAddress: string,
-        ownerAddress: string,
-        methodOpts?: MethodOpts,
-    ): Promise<BigNumber> {
+    public async getProxyAllowanceAsync(tokenAddress: string, ownerAddress: string,
+                                        methodOpts?: MethodOpts): Promise<BigNumber> {
         assert.isETHAddressHex('ownerAddress', ownerAddress);
         assert.isETHAddressHex('tokenAddress', tokenAddress);
-        const normalizedTokenAddress = tokenAddress.toLowerCase();
-        const normalizedOwnerAddress = ownerAddress.toLowerCase();
 
-        const proxyAddress = this._tokenTransferProxyWrapper.getContractAddress();
-        const allowanceInBaseUnits = await this.getAllowanceAsync(
-            normalizedTokenAddress,
-            normalizedOwnerAddress,
-            proxyAddress,
-            methodOpts,
-        );
+        const proxyAddress = await this._getTokenTransferProxyAddressAsync();
+        const allowanceInBaseUnits = await this.getAllowanceAsync(tokenAddress, ownerAddress, proxyAddress, methodOpts);
         return allowanceInBaseUnits;
     }
     /**
@@ -185,29 +144,16 @@ export class TokenWrapper extends ContractWrapper {
      * @param   ownerAddress        The hex encoded user Ethereum address who is setting an allowance
      *                              for the Proxy contract.
      * @param   amountInBaseUnits   The allowance amount specified in baseUnits.
-     * @param   txOpts              Transaction parameters.
      * @return Transaction hash.
      */
-    public async setProxyAllowanceAsync(
-        tokenAddress: string,
-        ownerAddress: string,
-        amountInBaseUnits: BigNumber,
-        txOpts: TransactionOpts = {},
-    ): Promise<string> {
+    public async setProxyAllowanceAsync(tokenAddress: string, ownerAddress: string,
+                                        amountInBaseUnits: BigNumber): Promise<string> {
         assert.isETHAddressHex('ownerAddress', ownerAddress);
         assert.isETHAddressHex('tokenAddress', tokenAddress);
-        const normalizedTokenAddress = tokenAddress.toLowerCase();
-        const normalizedOwnerAddress = ownerAddress.toLowerCase();
         assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
 
-        const proxyAddress = this._tokenTransferProxyWrapper.getContractAddress();
-        const txHash = await this.setAllowanceAsync(
-            normalizedTokenAddress,
-            normalizedOwnerAddress,
-            proxyAddress,
-            amountInBaseUnits,
-            txOpts,
-        );
+        const proxyAddress = await this._getTokenTransferProxyAddressAsync();
+        const txHash = await this.setAllowanceAsync(tokenAddress, ownerAddress, proxyAddress, amountInBaseUnits);
         return txHash;
     }
     /**
@@ -218,23 +164,11 @@ export class TokenWrapper extends ContractWrapper {
      * @param   tokenAddress        The hex encoded contract Ethereum address where the ERC20 token is deployed.
      * @param   ownerAddress        The hex encoded user Ethereum address who is setting an allowance
      *                              for the Proxy contract.
-     * @param   txOpts              Transaction parameters.
      * @return Transaction hash.
      */
-    public async setUnlimitedProxyAllowanceAsync(
-        tokenAddress: string,
-        ownerAddress: string,
-        txOpts: TransactionOpts = {},
-    ): Promise<string> {
-        assert.isETHAddressHex('ownerAddress', ownerAddress);
-        assert.isETHAddressHex('tokenAddress', tokenAddress);
-        const normalizedTokenAddress = tokenAddress.toLowerCase();
-        const normalizedOwnerAddress = ownerAddress.toLowerCase();
+    public async setUnlimitedProxyAllowanceAsync(tokenAddress: string, ownerAddress: string): Promise<string> {
         const txHash = await this.setProxyAllowanceAsync(
-            normalizedTokenAddress,
-            normalizedOwnerAddress,
-            this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS,
-            txOpts,
+            tokenAddress, ownerAddress, this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS,
         );
         return txHash;
     }
@@ -244,35 +178,24 @@ export class TokenWrapper extends ContractWrapper {
      * @param   fromAddress         The hex encoded user Ethereum address that will send the funds.
      * @param   toAddress           The hex encoded user Ethereum address that will receive the funds.
      * @param   amountInBaseUnits   The amount (specified in baseUnits) of the token to transfer.
-     * @param   txOpts              Transaction parameters.
      * @return Transaction hash.
      */
-    public async transferAsync(
-        tokenAddress: string,
-        fromAddress: string,
-        toAddress: string,
-        amountInBaseUnits: BigNumber,
-        txOpts: TransactionOpts = {},
-    ): Promise<string> {
+    public async transferAsync(tokenAddress: string, fromAddress: string, toAddress: string,
+                               amountInBaseUnits: BigNumber): Promise<string> {
         assert.isETHAddressHex('tokenAddress', tokenAddress);
-        assert.isETHAddressHex('toAddress', toAddress);
         await assert.isSenderAddressAsync('fromAddress', fromAddress, this._web3Wrapper);
-        const normalizedTokenAddress = tokenAddress.toLowerCase();
-        const normalizedFromAddress = fromAddress.toLowerCase();
-        const normalizedToAddress = toAddress.toLowerCase();
+        assert.isETHAddressHex('toAddress', toAddress);
         assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
 
-        const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
+        const tokenContract = await this._getTokenContractAsync(tokenAddress);
 
-        const fromAddressBalance = await this.getBalanceAsync(normalizedTokenAddress, normalizedFromAddress);
+        const fromAddressBalance = await this.getBalanceAsync(tokenAddress, fromAddress);
         if (fromAddressBalance.lessThan(amountInBaseUnits)) {
             throw new Error(ZeroExError.InsufficientBalanceForTransfer);
         }
 
-        const txHash = await tokenContract.transfer.sendTransactionAsync(normalizedToAddress, amountInBaseUnits, {
-            from: normalizedFromAddress,
-            gas: txOpts.gasLimit,
-            gasPrice: txOpts.gasPrice,
+        const txHash = await tokenContract.transfer.sendTransactionAsync(toAddress, amountInBaseUnits, {
+            from: fromAddress,
         });
         return txHash;
     }
@@ -287,51 +210,33 @@ export class TokenWrapper extends ContractWrapper {
      *                              `fromAddress` must have set an allowance to the `senderAddress`
      *                              before this call.
      * @param   amountInBaseUnits   The amount (specified in baseUnits) of the token to transfer.
-     * @param   txOpts              Transaction parameters.
      * @return Transaction hash.
      */
-    public async transferFromAsync(
-        tokenAddress: string,
-        fromAddress: string,
-        toAddress: string,
-        senderAddress: string,
-        amountInBaseUnits: BigNumber,
-        txOpts: TransactionOpts = {},
-    ): Promise<string> {
-        assert.isETHAddressHex('toAddress', toAddress);
-        assert.isETHAddressHex('fromAddress', fromAddress);
+    public async transferFromAsync(tokenAddress: string, fromAddress: string, toAddress: string,
+                                   senderAddress: string, amountInBaseUnits: BigNumber):
+                                   Promise<string> {
         assert.isETHAddressHex('tokenAddress', tokenAddress);
+        assert.isETHAddressHex('fromAddress', fromAddress);
+        assert.isETHAddressHex('toAddress', toAddress);
         await assert.isSenderAddressAsync('senderAddress', senderAddress, this._web3Wrapper);
-        const normalizedToAddress = toAddress.toLowerCase();
-        const normalizedFromAddress = fromAddress.toLowerCase();
-        const normalizedTokenAddress = tokenAddress.toLowerCase();
-        const normalizedSenderAddress = senderAddress.toLowerCase();
         assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
 
-        const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
+        const tokenContract = await this._getTokenContractAsync(tokenAddress);
 
-        const fromAddressAllowance = await this.getAllowanceAsync(
-            normalizedTokenAddress,
-            normalizedFromAddress,
-            normalizedSenderAddress,
-        );
+        const fromAddressAllowance = await this.getAllowanceAsync(tokenAddress, fromAddress, senderAddress);
         if (fromAddressAllowance.lessThan(amountInBaseUnits)) {
             throw new Error(ZeroExError.InsufficientAllowanceForTransfer);
         }
 
-        const fromAddressBalance = await this.getBalanceAsync(normalizedTokenAddress, normalizedFromAddress);
+        const fromAddressBalance = await this.getBalanceAsync(tokenAddress, fromAddress);
         if (fromAddressBalance.lessThan(amountInBaseUnits)) {
             throw new Error(ZeroExError.InsufficientBalanceForTransfer);
         }
 
         const txHash = await tokenContract.transferFrom.sendTransactionAsync(
-            normalizedFromAddress,
-            normalizedToAddress,
-            amountInBaseUnits,
+            fromAddress, toAddress, amountInBaseUnits,
             {
-                from: normalizedSenderAddress,
-                gas: txOpts.gasLimit,
-                gasPrice: txOpts.gasPrice,
+                from: senderAddress,
             },
         );
         return txHash;
@@ -346,22 +251,14 @@ export class TokenWrapper extends ContractWrapper {
      * @return Subscription token used later to unsubscribe
      */
     public subscribe<ArgsType extends TokenContractEventArgs>(
-        tokenAddress: string,
-        eventName: TokenEvents,
-        indexFilterValues: IndexedFilterValues,
-        callback: EventCallback<ArgsType>,
-    ): string {
+        tokenAddress: string, eventName: TokenEvents, indexFilterValues: IndexedFilterValues,
+        callback: EventCallback<ArgsType>): string {
         assert.isETHAddressHex('tokenAddress', tokenAddress);
-        const normalizedTokenAddress = tokenAddress.toLowerCase();
         assert.doesBelongToStringEnum('eventName', eventName, TokenEvents);
         assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
         assert.isFunction('callback', callback);
         const subscriptionToken = this._subscribe<ArgsType>(
-            normalizedTokenAddress,
-            eventName,
-            indexFilterValues,
-            artifacts.TokenArtifact.abi,
-            callback,
+            tokenAddress, eventName, indexFilterValues, artifacts.TokenArtifact.abi, callback,
         );
         return subscriptionToken;
     }
@@ -372,58 +269,45 @@ export class TokenWrapper extends ContractWrapper {
     public unsubscribe(subscriptionToken: string): void {
         this._unsubscribe(subscriptionToken);
     }
-    /**
-     * Cancels all existing subscriptions
-     */
-    public unsubscribeAll(): void {
-        super._unsubscribeAll();
-    }
     /**
      * Gets historical logs without creating a subscription
-     * @param   tokenAddress        An address of the token that emitted the logs.
+     * @param   tokenAddress        An address of the token that emmited the logs.
      * @param   eventName           The token contract event you would like to subscribe to.
-     * @param   blockRange          Block range to get logs from.
+     * @param   subscriptionOpts    Subscriptions options that let you configure the subscription.
      * @param   indexFilterValues   An object where the keys are indexed args returned by the event and
      *                              the value is the value you are interested in. E.g `{_from: aUserAddressHex}`
      * @return  Array of logs that match the parameters
      */
     public async getLogsAsync<ArgsType extends TokenContractEventArgs>(
-        tokenAddress: string,
-        eventName: TokenEvents,
-        blockRange: BlockRange,
-        indexFilterValues: IndexedFilterValues,
-    ): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
+        tokenAddress: string, eventName: TokenEvents, subscriptionOpts: SubscriptionOpts,
+        indexFilterValues: IndexedFilterValues): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
         assert.isETHAddressHex('tokenAddress', tokenAddress);
-        const normalizedTokenAddress = tokenAddress.toLowerCase();
         assert.doesBelongToStringEnum('eventName', eventName, TokenEvents);
-        assert.doesConformToSchema('blockRange', blockRange, schemas.blockRangeSchema);
+        assert.doesConformToSchema('subscriptionOpts', subscriptionOpts, schemas.subscriptionOptsSchema);
         assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
         const logs = await this._getLogsAsync<ArgsType>(
-            normalizedTokenAddress,
-            eventName,
-            blockRange,
-            indexFilterValues,
-            artifacts.TokenArtifact.abi,
+            tokenAddress, eventName, subscriptionOpts, indexFilterValues, artifacts.TokenArtifact.abi,
         );
         return logs;
     }
-    private _invalidateContractInstances(): void {
+    private _invalidateContractInstancesAsync(): void {
         this.unsubscribeAll();
         this._tokenContractsByAddress = {};
     }
     private async _getTokenContractAsync(tokenAddress: string): Promise<TokenContract> {
-        const normalizedTokenAddress = tokenAddress.toLowerCase();
-        let tokenContract = this._tokenContractsByAddress[normalizedTokenAddress];
+        let tokenContract = this._tokenContractsByAddress[tokenAddress];
         if (!_.isUndefined(tokenContract)) {
             return tokenContract;
         }
-        const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
-            artifacts.TokenArtifact,
-            normalizedTokenAddress,
+        const contractInstance = await this._instantiateContractIfExistsAsync<TokenContract>(
+            artifacts.TokenArtifact, tokenAddress,
         );
-        const contractInstance = new TokenContract(this._web3Wrapper, abi, address);
-        tokenContract = contractInstance;
-        this._tokenContractsByAddress[normalizedTokenAddress] = tokenContract;
+        tokenContract = contractInstance as TokenContract;
+        this._tokenContractsByAddress[tokenAddress] = tokenContract;
         return tokenContract;
     }
+    private async _getTokenTransferProxyAddressAsync(): Promise<string> {
+        const tokenTransferProxyContractAddress = await this._tokenTransferProxyContractAddressFetcher();
+        return tokenTransferProxyContractAddress;
+    }
 }

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

@@ -1,10 +1,24 @@
+/// <reference types='chai-typescript-typings' />
+/// <reference types='chai-as-promised-typescript-typings' />
 declare module 'web3_beta';
+declare module 'chai-bignumber';
+declare module 'dirty-chai';
 declare module 'request-promise-native';
+declare module 'web3-provider-engine';
+declare module 'web3-provider-engine/subproviders/rpc';
 
-// semver-sort declarations
-declare module 'semver-sort' {
-    const desc: (versions: string[]) => string[];
+// HACK: In order to merge the bignumber declaration added by chai-bignumber to the chai Assertion
+// interface we must use `namespace` as the Chai definitelyTyped definition does. Since we otherwise
+// disallow `namespace`, we disable tslint for the following.
+/* tslint:disable */
+declare namespace Chai {
+    interface Assertion {
+        bignumber: Assertion;
+        // HACK: In order to comply with chai-as-promised we make eventually a `PromisedAssertion` not an `Assertion`
+        eventually: PromisedAssertion;
+    }
 }
+/* tslint:enable */
 
 declare module '*.json' {
     const json: any;
@@ -12,3 +26,55 @@ declare module '*.json' {
     export default json;
     /* tslint:enable */
 }
+
+// find-version declarations
+declare function findVersions(version: string): string[];
+declare module 'find-versions' {
+    export = findVersions;
+}
+
+// compare-version declarations
+declare function compareVersions(firstVersion: string, secondVersion: string): number;
+declare module 'compare-versions' {
+    export = compareVersions;
+}
+
+// es6-promisify declarations
+declare function promisify(original: any, settings?: any): ((...arg: any[]) => Promise<any>);
+declare module 'es6-promisify' {
+    export = promisify;
+}
+
+declare module 'ethereumjs-abi' {
+    const soliditySHA3: (argTypes: string[], args: any[]) => Buffer;
+}
+
+// truffle-hdwallet-provider declarations
+declare module 'truffle-hdwallet-provider' {
+    import * as Web3 from 'web3';
+    class HDWalletProvider implements Web3.Provider {
+        constructor(mnemonic: string, rpcUrl: string);
+        public sendAsync(
+            payload: Web3.JSONRPCRequestPayload,
+            callback: (err: Error, result: Web3.JSONRPCResponsePayload) => void,
+        ): void;
+    }
+    export = HDWalletProvider;
+}
+
+// abi-decoder declarations
+interface DecodedLogArg {
+}
+interface DecodedLog {
+    name: string;
+    events: DecodedLogArg[];
+}
+declare module 'abi-decoder' {
+    import * as Web3 from 'web3';
+    const addABI: (abi: Web3.AbiDefinition) => void;
+    const decodeLogs: (logs: Web3.LogEntry[]) => DecodedLog[];
+}
+
+declare module 'web3/lib/solidity/coder' {
+    const decodeParams: (types: string[], data: string) => any[];
+}

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

@@ -0,0 +1,23 @@
+import BigNumber from 'bignumber.js';
+
+// HACK: This module overrides the Chai namespace so that we can use BigNumber types inside.
+// Source: https://github.com/Microsoft/TypeScript/issues/7352#issuecomment-191547232
+declare global {
+    // HACK: In order to merge the bignumber declaration added by chai-bignumber to the chai Assertion
+    // interface we must use `namespace` as the Chai definitelyTyped definition does. Since we otherwise
+    // disallow `namespace`, we disable tslint for the following.
+    /* tslint:disable */
+    namespace Chai {
+        interface NumberComparer {
+            (value: number|BigNumber, message?: string): Assertion;
+        }
+        interface NumericComparison {
+            greaterThan: NumberComparer;
+        }
+    }
+    /* tslint:enable */
+    interface DecodedLogArg {
+        name: string;
+        value: string|BigNumber;
+    }
+}

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

@@ -1,21 +1,38 @@
-export { ZeroEx } from './0x';
+export {ZeroEx} from './0x';
 
 export {
+    Order,
+    SignedOrder,
+    ECSignature,
     ZeroExError,
     EventCallback,
     ExchangeContractErrs,
     ContractEvent,
     Token,
+    ExchangeEvents,
+    TokenEvents,
     IndexedFilterValues,
-    BlockRange,
+    SubscriptionOpts,
+    BlockParam,
     OrderCancellationRequest,
     OrderFillRequest,
+    LogErrorContractEventArgs,
+    LogCancelContractEventArgs,
+    LogFillContractEventArgs,
+    ExchangeContractEventArgs,
+    TransferContractEventArgs,
+    ApprovalContractEventArgs,
+    TokenContractEventArgs,
     ContractEventArgs,
+    ContractEventArg,
     Web3Provider,
     ZeroExConfig,
+    TransactionReceipt,
+    TransactionReceiptWithDecodedLogs,
+    LogWithDecodedArgs,
     MethodOpts,
     OrderTransactionOpts,
-    TransactionOpts,
+    FilterObject,
     LogEvent,
     DecodedLogEvent,
     EventWatcherCallback,
@@ -24,38 +41,3 @@ export {
     OrderStateInvalid,
     OrderState,
 } from './types';
-
-export {
-    BlockParamLiteral,
-    FilterObject,
-    BlockParam,
-    ContractEventArg,
-    LogWithDecodedArgs,
-    Order,
-    SignedOrder,
-    ECSignature,
-    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';

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

@@ -1,8 +0,0 @@
-import { postpublishUtils } from '@0xproject/monorepo-scripts';
-
-import * as packageJSON from '../package.json';
-import * as tsConfigJSON from '../tsconfig.json';
-
-const cwd = `${__dirname}/..`;
-// tslint:disable-next-line:no-floating-promises
-postpublishUtils.runAsync(packageJSON, tsConfigJSON, cwd);

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

@@ -1,8 +0,0 @@
-import { postpublishUtils } from '@0xproject/monorepo-scripts';
-
-import * as packageJSON from '../package.json';
-import * as tsConfigJSON from '../tsconfig.json';
-
-const cwd = `${__dirname}/..`;
-// tslint:disable-next-line:no-floating-promises
-postpublishUtils.publishDocsToStagingAsync(packageJSON, tsConfigJSON, cwd);

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

@@ -1,10 +1,16 @@
-import { BlockParamLiteral, LogEntry } from '@0xproject/types';
-import { intervalUtils } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as Web3 from 'web3';
 import * as _ from 'lodash';
-
-import { EventWatcherCallback, ZeroExError } from '../types';
-import { assert } from '../utils/assert';
+import {Web3Wrapper} from '../web3_wrapper';
+import {
+    BlockParamLiteral,
+    EventCallback,
+    EventWatcherCallback,
+    ZeroExError,
+} from '../types';
+import {AbiDecoder} from '../utils/abi_decoder';
+import {intervalUtils} from '../utils/interval_utils';
+import {assert} from '../utils/assert';
+import {utils} from '../utils/utils';
 
 const DEFAULT_EVENT_POLLING_INTERVAL_MS = 200;
 
@@ -21,18 +27,12 @@ export class EventWatcher {
     private _web3Wrapper: Web3Wrapper;
     private _pollingIntervalMs: number;
     private _intervalIdIfExists?: NodeJS.Timer;
-    private _lastEvents: LogEntry[] = [];
-    private _stateLayer: BlockParamLiteral;
-    constructor(
-        web3Wrapper: Web3Wrapper,
-        pollingIntervalIfExistsMs: undefined | number,
-        stateLayer: BlockParamLiteral = BlockParamLiteral.Latest,
-    ) {
+    private _lastEvents: Web3.LogEntry[] = [];
+    constructor(web3Wrapper: Web3Wrapper, pollingIntervalIfExistsMs: undefined|number) {
         this._web3Wrapper = web3Wrapper;
-        this._stateLayer = stateLayer;
-        this._pollingIntervalMs = _.isUndefined(pollingIntervalIfExistsMs)
-            ? DEFAULT_EVENT_POLLING_INTERVAL_MS
-            : pollingIntervalIfExistsMs;
+        this._pollingIntervalMs = _.isUndefined(pollingIntervalIfExistsMs) ?
+                                    DEFAULT_EVENT_POLLING_INTERVAL_MS :
+                                    pollingIntervalIfExistsMs;
     }
     public subscribe(callback: EventWatcherCallback): void {
         assert.isFunction('callback', callback);
@@ -40,12 +40,7 @@ export class EventWatcher {
             throw new Error(ZeroExError.SubscriptionAlreadyPresent);
         }
         this._intervalIdIfExists = intervalUtils.setAsyncExcludingInterval(
-            this._pollForBlockchainEventsAsync.bind(this, callback),
-            this._pollingIntervalMs,
-            (err: Error) => {
-                this.unsubscribe();
-                callback(err);
-            },
+            this._pollForBlockchainEventsAsync.bind(this, callback), this._pollingIntervalMs,
         );
     }
     public unsubscribe(): void {
@@ -57,10 +52,6 @@ export class EventWatcher {
     }
     private async _pollForBlockchainEventsAsync(callback: EventWatcherCallback): Promise<void> {
         const pendingEvents = await this._getEventsAsync();
-        if (_.isUndefined(pendingEvents)) {
-            // HACK: This should never happen, but happens frequently on CI due to a ganache bug
-            return;
-        }
         if (pendingEvents.length === 0) {
             // HACK: Sometimes when node rebuilds the pending block we get back the empty result.
             // We don't want to emit a lot of removal events and bring them back after a couple of miliseconds,
@@ -73,18 +64,16 @@ export class EventWatcher {
         await this._emitDifferencesAsync(newEvents, LogEventState.Added, callback);
         this._lastEvents = pendingEvents;
     }
-    private async _getEventsAsync(): Promise<LogEntry[]> {
+    private async _getEventsAsync(): Promise<Web3.LogEntry[]> {
         const eventFilter = {
-            fromBlock: this._stateLayer,
-            toBlock: this._stateLayer,
+            fromBlock: BlockParamLiteral.Pending,
+            toBlock: BlockParamLiteral.Pending,
         };
         const events = await this._web3Wrapper.getLogsAsync(eventFilter);
         return events;
     }
     private async _emitDifferencesAsync(
-        logs: LogEntry[],
-        logEventState: LogEventState,
-        callback: EventWatcherCallback,
+        logs: Web3.LogEntry[], logEventState: LogEventState, callback: EventWatcherCallback,
     ): Promise<void> {
         for (const log of logs) {
             const logEvent = {
@@ -92,7 +81,7 @@ export class EventWatcher {
                 ...log,
             };
             if (!_.isUndefined(this._intervalIdIfExists)) {
-                callback(null, logEvent);
+                callback(logEvent);
             }
         }
     }

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

@@ -1,9 +1,10 @@
-import { BigNumber, intervalUtils } from '@0xproject/utils';
-import { RBTree } from 'bintrees';
 import * as _ from 'lodash';
-
-import { ZeroExError } from '../types';
-import { utils } from '../utils/utils';
+import {BigNumber} from 'bignumber.js';
+import {RBTree} from 'bintrees';
+import {utils} from '../utils/utils';
+import {intervalUtils} from '../utils/interval_utils';
+import {SignedOrder, ZeroExError} from '../types';
+import {ZeroEx} from '../0x';
 
 const DEFAULT_EXPIRATION_MARGIN_MS = 0;
 const DEFAULT_ORDER_EXPIRATION_CHECKING_INTERVAL_MS = 50;
@@ -13,63 +14,63 @@ const DEFAULT_ORDER_EXPIRATION_CHECKING_INTERVAL_MS = 50;
  * It stores them in a min heap by expiration time and checks for expired ones every `orderExpirationCheckingIntervalMs`
  */
 export class ExpirationWatcher {
-    private _orderHashByExpirationRBTree: RBTree<string>;
-    private _expiration: { [orderHash: string]: BigNumber } = {};
-    private _orderExpirationCheckingIntervalMs: number;
-    private _expirationMarginMs: number;
-    private _orderExpirationCheckingIntervalIdIfExists?: NodeJS.Timer;
-    constructor(expirationMarginIfExistsMs?: number, orderExpirationCheckingIntervalIfExistsMs?: number) {
-        this._expirationMarginMs = expirationMarginIfExistsMs || DEFAULT_EXPIRATION_MARGIN_MS;
-        this._orderExpirationCheckingIntervalMs =
-            expirationMarginIfExistsMs || DEFAULT_ORDER_EXPIRATION_CHECKING_INTERVAL_MS;
-        const scoreFunction = (orderHash: string) => this._expiration[orderHash].toNumber();
+    private orderHashByExpirationRBTree: RBTree<string>;
+    private expiration: {[orderHash: string]: BigNumber} = {};
+    private orderExpirationCheckingIntervalMs: number;
+    private expirationMarginMs: number;
+    private orderExpirationCheckingIntervalIdIfExists?: NodeJS.Timer;
+    constructor(expirationMarginIfExistsMs?: number,
+                orderExpirationCheckingIntervalIfExistsMs?: number) {
+        this.expirationMarginMs = expirationMarginIfExistsMs ||
+                                  DEFAULT_EXPIRATION_MARGIN_MS;
+        this.orderExpirationCheckingIntervalMs = expirationMarginIfExistsMs ||
+                                                 DEFAULT_ORDER_EXPIRATION_CHECKING_INTERVAL_MS;
+        const scoreFunction = (orderHash: string) => this.expiration[orderHash].toNumber();
         const comparator = (lhs: string, rhs: string) => scoreFunction(lhs) - scoreFunction(rhs);
-        this._orderHashByExpirationRBTree = new RBTree(comparator);
+        this.orderHashByExpirationRBTree = new RBTree(comparator);
     }
-    public subscribe(callback: (orderHash: string) => void): void {
-        if (!_.isUndefined(this._orderExpirationCheckingIntervalIdIfExists)) {
+    public subscribe(callbackAsync: (orderHash: string) => Promise<void>): void {
+        if (!_.isUndefined(this.orderExpirationCheckingIntervalIdIfExists)) {
             throw new Error(ZeroExError.SubscriptionAlreadyPresent);
         }
-        this._orderExpirationCheckingIntervalIdIfExists = intervalUtils.setInterval(
-            this._pruneExpiredOrders.bind(this, callback),
-            this._orderExpirationCheckingIntervalMs,
-            _.noop, // _pruneExpiredOrders never throws
+        this.orderExpirationCheckingIntervalIdIfExists = intervalUtils.setAsyncExcludingInterval(
+            this.pruneExpiredOrdersAsync.bind(this, callbackAsync), this.orderExpirationCheckingIntervalMs,
         );
     }
     public unsubscribe(): void {
-        if (_.isUndefined(this._orderExpirationCheckingIntervalIdIfExists)) {
+        if (_.isUndefined(this.orderExpirationCheckingIntervalIdIfExists)) {
             throw new Error(ZeroExError.SubscriptionNotFound);
         }
-        intervalUtils.clearInterval(this._orderExpirationCheckingIntervalIdIfExists);
-        delete this._orderExpirationCheckingIntervalIdIfExists;
+        intervalUtils.clearAsyncExcludingInterval(this.orderExpirationCheckingIntervalIdIfExists);
+        delete this.orderExpirationCheckingIntervalIdIfExists;
     }
     public addOrder(orderHash: string, expirationUnixTimestampMs: BigNumber): void {
-        this._expiration[orderHash] = expirationUnixTimestampMs;
-        this._orderHashByExpirationRBTree.insert(orderHash);
+        this.expiration[orderHash] = expirationUnixTimestampMs;
+        this.orderHashByExpirationRBTree.insert(orderHash);
     }
     public removeOrder(orderHash: string): void {
-        this._orderHashByExpirationRBTree.remove(orderHash);
-        delete this._expiration[orderHash];
+        this.orderHashByExpirationRBTree.remove(orderHash);
+        delete this.expiration[orderHash];
     }
-    private _pruneExpiredOrders(callback: (orderHash: string) => void): void {
+    private async pruneExpiredOrdersAsync(callbackAsync: (orderHash: string) => Promise<void>): Promise<void> {
         const currentUnixTimestampMs = utils.getCurrentUnixTimestampMs();
         while (true) {
-            const hasTrakedOrders = this._orderHashByExpirationRBTree.size === 0;
+            const hasTrakedOrders = this.orderHashByExpirationRBTree.size === 0;
             if (hasTrakedOrders) {
                 break;
             }
-            const nextOrderHashToExpire = this._orderHashByExpirationRBTree.min();
-            const hasNoExpiredOrders = this._expiration[nextOrderHashToExpire].greaterThan(
-                currentUnixTimestampMs.plus(this._expirationMarginMs),
+            const nextOrderHashToExpire = this.orderHashByExpirationRBTree.min();
+            const hasNoExpiredOrders = this.expiration[nextOrderHashToExpire].greaterThan(
+                currentUnixTimestampMs.plus(this.expirationMarginMs),
             );
-            const isSubscriptionActive = _.isUndefined(this._orderExpirationCheckingIntervalIdIfExists);
+            const isSubscriptionActive = _.isUndefined(this.orderExpirationCheckingIntervalIdIfExists);
             if (hasNoExpiredOrders || isSubscriptionActive) {
                 break;
             }
-            const orderHash = this._orderHashByExpirationRBTree.min();
-            this._orderHashByExpirationRBTree.remove(orderHash);
-            delete this._expiration[orderHash];
-            callback(orderHash);
+            const orderHash = this.orderHashByExpirationRBTree.min();
+            this.orderHashByExpirationRBTree.remove(orderHash);
+            delete this.expiration[orderHash];
+            await callbackAsync(orderHash);
         }
     }
 }

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

@@ -1,48 +1,42 @@
-import { schemas } from '@0xproject/json-schemas';
-import { BlockParamLiteral, LogWithDecodedArgs, SignedOrder } from '@0xproject/types';
-import { AbiDecoder, intervalUtils } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
-
-import { ZeroEx } from '../0x';
-import { ExchangeWrapper } from '../contract_wrappers/exchange_wrapper';
+import {schemas} from '@0xproject/json-schemas';
+import {ZeroEx} from '../0x';
+import {EventWatcher} from './event_watcher';
+import {assert} from '../utils/assert';
+import {utils} from '../utils/utils';
+import {artifacts} from '../artifacts';
+import {AbiDecoder} from '../utils/abi_decoder';
+import {intervalUtils} from '../utils/interval_utils';
+import {OrderStateUtils} from '../utils/order_state_utils';
 import {
-    DepositContractEventArgs,
-    EtherTokenEvents,
-    WithdrawalContractEventArgs,
-} from '../contract_wrappers/generated/ether_token';
-import {
-    ExchangeEvents,
-    LogCancelContractEventArgs,
-    LogFillContractEventArgs,
-} from '../contract_wrappers/generated/exchange';
-import {
-    ApprovalContractEventArgs,
-    TokenEvents,
-    TransferContractEventArgs,
-} from '../contract_wrappers/generated/token';
-import { TokenWrapper } from '../contract_wrappers/token_wrapper';
-import { BalanceAndProxyAllowanceLazyStore } from '../stores/balance_proxy_allowance_lazy_store';
-import { OrderFilledCancelledLazyStore } from '../stores/order_filled_cancelled_lazy_store';
-import {
-    ContractEventArgs,
-    ExchangeContractErrs,
     LogEvent,
-    OnOrderStateChangeCallback,
     OrderState,
+    SignedOrder,
+    Web3Provider,
+    BlockParamLiteral,
+    LogWithDecodedArgs,
+    ContractEventArgs,
+    OnOrderStateChangeCallback,
     OrderStateWatcherConfig,
+    ApprovalContractEventArgs,
+    TransferContractEventArgs,
+    LogFillContractEventArgs,
+    LogCancelContractEventArgs,
+    ExchangeEvents,
+    TokenEvents,
     ZeroExError,
+    ExchangeContractErrs,
 } from '../types';
-import { assert } from '../utils/assert';
-import { OrderStateUtils } from '../utils/order_state_utils';
-import { utils } from '../utils/utils';
-
-import { EventWatcher } from './event_watcher';
-import { ExpirationWatcher } from './expiration_watcher';
+import {Web3Wrapper} from '../web3_wrapper';
+import {TokenWrapper} from '../contract_wrappers/token_wrapper';
+import {ExchangeWrapper} from '../contract_wrappers/exchange_wrapper';
+import {OrderFilledCancelledLazyStore} from '../stores/order_filled_cancelled_lazy_store';
+import {BalanceAndProxyAllowanceLazyStore} from '../stores/balance_proxy_allowance_lazy_store';
+import {ExpirationWatcher} from './expiration_watcher';
 
 interface DependentOrderHashes {
     [makerAddress: string]: {
-        [makerToken: string]: Set<string>;
+        [makerToken: string]: Set<string>,
     };
 }
 
@@ -50,72 +44,57 @@ interface OrderByOrderHash {
     [orderHash: string]: SignedOrder;
 }
 
-interface OrderStateByOrderHash {
-    [orderHash: string]: OrderState;
-}
-
-const DEFAULT_CLEANUP_JOB_INTERVAL_MS = 1000 * 60 * 60; // 1h
-
 /**
  * This class includes all the functionality related to watching a set of orders
  * for potential changes in order validity/fillability. The orderWatcher notifies
- * the subscriber of these changes so that a final decision can be made on whether
+ * the subscriber of these changes so that a final decison can be made on whether
  * the order should be deemed invalid.
  */
 export class OrderStateWatcher {
-    private _orderStateByOrderHashCache: OrderStateByOrderHash = {};
     private _orderByOrderHash: OrderByOrderHash = {};
     private _dependentOrderHashes: DependentOrderHashes = {};
     private _callbackIfExists?: OnOrderStateChangeCallback;
     private _eventWatcher: EventWatcher;
     private _web3Wrapper: Web3Wrapper;
+    private _abiDecoder: AbiDecoder;
     private _expirationWatcher: ExpirationWatcher;
     private _orderStateUtils: OrderStateUtils;
     private _orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore;
     private _balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore;
-    private _cleanupJobInterval: number;
-    private _cleanupJobIntervalIdIfExists?: NodeJS.Timer;
     constructor(
-        web3Wrapper: Web3Wrapper,
-        token: TokenWrapper,
-        exchange: ExchangeWrapper,
+        web3Wrapper: Web3Wrapper, abiDecoder: AbiDecoder, token: TokenWrapper, exchange: ExchangeWrapper,
         config?: OrderStateWatcherConfig,
     ) {
+        this._abiDecoder = abiDecoder;
         this._web3Wrapper = web3Wrapper;
         const pollingIntervalIfExistsMs = _.isUndefined(config) ? undefined : config.eventPollingIntervalMs;
-        const stateLayer =
-            _.isUndefined(config) || _.isUndefined(config.stateLayer) ? BlockParamLiteral.Latest : config.stateLayer;
-        this._eventWatcher = new EventWatcher(web3Wrapper, pollingIntervalIfExistsMs, stateLayer);
-        this._balanceAndProxyAllowanceLazyStore = new BalanceAndProxyAllowanceLazyStore(token, stateLayer);
+        this._eventWatcher = new EventWatcher(web3Wrapper, pollingIntervalIfExistsMs);
+        this._balanceAndProxyAllowanceLazyStore = new BalanceAndProxyAllowanceLazyStore(token);
         this._orderFilledCancelledLazyStore = new OrderFilledCancelledLazyStore(exchange);
         this._orderStateUtils = new OrderStateUtils(
-            this._balanceAndProxyAllowanceLazyStore,
-            this._orderFilledCancelledLazyStore,
+            this._balanceAndProxyAllowanceLazyStore, this._orderFilledCancelledLazyStore,
         );
-        const orderExpirationCheckingIntervalMsIfExists = _.isUndefined(config)
-            ? undefined
-            : config.orderExpirationCheckingIntervalMs;
-        const expirationMarginIfExistsMs = _.isUndefined(config) ? undefined : config.expirationMarginMs;
+        const orderExpirationCheckingIntervalMsIfExists = _.isUndefined(config) ?
+                                                          undefined :
+                                                          config.orderExpirationCheckingIntervalMs;
+        const expirationMarginIfExistsMs = _.isUndefined(config) ?
+                                           undefined :
+                                           config.expirationMarginMs;
         this._expirationWatcher = new ExpirationWatcher(
-            expirationMarginIfExistsMs,
-            orderExpirationCheckingIntervalMsIfExists,
+            expirationMarginIfExistsMs, orderExpirationCheckingIntervalMsIfExists,
         );
-        this._cleanupJobInterval =
-            _.isUndefined(config) || _.isUndefined(config.cleanupJobIntervalMs)
-                ? DEFAULT_CLEANUP_JOB_INTERVAL_MS
-                : config.cleanupJobIntervalMs;
     }
     /**
      * Add an order to the orderStateWatcher. Before the order is added, it's
      * signature is verified.
      * @param   signedOrder     The order you wish to start watching.
      */
-    public addOrder(signedOrder: SignedOrder): void {
+    public async addOrderAsync(signedOrder: SignedOrder): Promise<void> {
         assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
         const orderHash = ZeroEx.getOrderHashHex(signedOrder);
         assert.isValidSignature(orderHash, signedOrder.ecSignature, signedOrder.maker);
         this._orderByOrderHash[orderHash] = signedOrder;
-        this._addToDependentOrderHashes(signedOrder, orderHash);
+        await this.addToDependentOrderHashesAsync(signedOrder, orderHash);
         const expirationUnixTimestampMs = signedOrder.expirationUnixTimestampSec.times(1000);
         this._expirationWatcher.addOrder(orderHash, expirationUnixTimestampMs);
     }
@@ -123,22 +102,17 @@ export class OrderStateWatcher {
      * Removes an order from the orderStateWatcher
      * @param   orderHash     The orderHash of the order you wish to stop watching.
      */
-    public removeOrder(orderHash: string): void {
+    public async removeOrderAsync(orderHash: string): Promise<void> {
         assert.doesConformToSchema('orderHash', orderHash, schemas.orderHashSchema);
         const signedOrder = this._orderByOrderHash[orderHash];
         if (_.isUndefined(signedOrder)) {
             return; // noop
         }
         delete this._orderByOrderHash[orderHash];
-        delete this._orderStateByOrderHashCache[orderHash];
-        const exchange = (this._orderFilledCancelledLazyStore as any)._exchange as ExchangeWrapper;
-        const zrxTokenAddress = exchange.getZRXTokenAddress();
-
-        this._removeFromDependentOrderHashes(signedOrder.maker, zrxTokenAddress, orderHash);
-        if (zrxTokenAddress !== signedOrder.makerTokenAddress) {
-            this._removeFromDependentOrderHashes(signedOrder.maker, signedOrder.makerTokenAddress, orderHash);
-        }
-
+        const exchange = (this._orderFilledCancelledLazyStore as any).exchange as ExchangeWrapper;
+        const zrxTokenAddress = await exchange.getZRXTokenAddressAsync();
+        this.removeFromDependentOrderHashes(signedOrder.maker, zrxTokenAddress, orderHash);
+        this.removeFromDependentOrderHashes(signedOrder.maker, signedOrder.makerTokenAddress, orderHash);
         this._expirationWatcher.removeOrder(orderHash);
     }
     /**
@@ -154,21 +128,13 @@ export class OrderStateWatcher {
         }
         this._callbackIfExists = callback;
         this._eventWatcher.subscribe(this._onEventWatcherCallbackAsync.bind(this));
-        this._expirationWatcher.subscribe(this._onOrderExpired.bind(this));
-        this._cleanupJobIntervalIdIfExists = intervalUtils.setAsyncExcludingInterval(
-            this._cleanupAsync.bind(this),
-            this._cleanupJobInterval,
-            (err: Error) => {
-                this.unsubscribe();
-                callback(err);
-            },
-        );
+        this._expirationWatcher.subscribe(this._onOrderExpiredAsync.bind(this));
     }
     /**
      * Ends an orderStateWatcher subscription.
      */
     public unsubscribe(): void {
-        if (_.isUndefined(this._callbackIfExists) || _.isUndefined(this._cleanupJobIntervalIdIfExists)) {
+        if (_.isUndefined(this._callbackIfExists)) {
             throw new Error(ZeroExError.SubscriptionNotFound);
         }
         this._balanceAndProxyAllowanceLazyStore.deleteAll();
@@ -176,83 +142,47 @@ export class OrderStateWatcher {
         delete this._callbackIfExists;
         this._eventWatcher.unsubscribe();
         this._expirationWatcher.unsubscribe();
-        intervalUtils.clearAsyncExcludingInterval(this._cleanupJobIntervalIdIfExists);
     }
-    private async _cleanupAsync(): Promise<void> {
-        for (const orderHash of _.keys(this._orderByOrderHash)) {
-            this._cleanupOrderRelatedState(orderHash);
-            await this._emitRevalidateOrdersAsync([orderHash]);
-        }
-    }
-    private _cleanupOrderRelatedState(orderHash: string): void {
-        const signedOrder = this._orderByOrderHash[orderHash];
-
-        this._orderFilledCancelledLazyStore.deleteFilledTakerAmount(orderHash);
-        this._orderFilledCancelledLazyStore.deleteCancelledTakerAmount(orderHash);
-
-        this._balanceAndProxyAllowanceLazyStore.deleteBalance(signedOrder.makerTokenAddress, signedOrder.maker);
-        this._balanceAndProxyAllowanceLazyStore.deleteProxyAllowance(signedOrder.makerTokenAddress, signedOrder.maker);
-        this._balanceAndProxyAllowanceLazyStore.deleteBalance(signedOrder.takerTokenAddress, signedOrder.taker);
-        this._balanceAndProxyAllowanceLazyStore.deleteProxyAllowance(signedOrder.takerTokenAddress, signedOrder.taker);
-
-        const zrxTokenAddress = this._getZRXTokenAddress();
-        if (!signedOrder.makerFee.isZero()) {
-            this._balanceAndProxyAllowanceLazyStore.deleteBalance(zrxTokenAddress, signedOrder.maker);
-            this._balanceAndProxyAllowanceLazyStore.deleteProxyAllowance(zrxTokenAddress, signedOrder.maker);
-        }
-        if (!signedOrder.takerFee.isZero()) {
-            this._balanceAndProxyAllowanceLazyStore.deleteBalance(zrxTokenAddress, signedOrder.taker);
-            this._balanceAndProxyAllowanceLazyStore.deleteProxyAllowance(zrxTokenAddress, signedOrder.taker);
-        }
-    }
-    private _onOrderExpired(orderHash: string): void {
+    private async _onOrderExpiredAsync(orderHash: string): Promise<void> {
         const orderState: OrderState = {
             isValid: false,
             orderHash,
             error: ExchangeContractErrs.OrderFillExpired,
         };
         if (!_.isUndefined(this._orderByOrderHash[orderHash])) {
-            this.removeOrder(orderHash);
+            await this.removeOrderAsync(orderHash);
             if (!_.isUndefined(this._callbackIfExists)) {
-                this._callbackIfExists(null, orderState);
+                this._callbackIfExists(orderState);
             }
         }
     }
-    private async _onEventWatcherCallbackAsync(err: Error | null, logIfExists?: LogEvent): Promise<void> {
-        if (!_.isNull(err)) {
-            if (!_.isUndefined(this._callbackIfExists)) {
-                this._callbackIfExists(err);
-                this.unsubscribe();
-            }
-            return;
-        }
-        const log = logIfExists as LogEvent; // At this moment we are sure that no error occured and log is defined.
-        const maybeDecodedLog = this._web3Wrapper.abiDecoder.tryToDecodeLogOrNoop<ContractEventArgs>(log);
-        const isLogDecoded = !_.isUndefined(((maybeDecodedLog as any) as LogWithDecodedArgs<ContractEventArgs>).event);
+    private async _onEventWatcherCallbackAsync(log: LogEvent): Promise<void> {
+        const maybeDecodedLog = this._abiDecoder.tryToDecodeLogOrNoop(log);
+        const isLogDecoded = !_.isUndefined((maybeDecodedLog as LogWithDecodedArgs<any>).event);
         if (!isLogDecoded) {
             return; // noop
         }
-        const decodedLog = (maybeDecodedLog as any) as LogWithDecodedArgs<ContractEventArgs>;
+        const decodedLog = maybeDecodedLog as LogWithDecodedArgs<ContractEventArgs>;
         let makerToken: string;
         let makerAddress: string;
         switch (decodedLog.event) {
-            case TokenEvents.Approval: {
+            case TokenEvents.Approval:
+            {
                 // Invalidate cache
                 const args = decodedLog.args as ApprovalContractEventArgs;
                 this._balanceAndProxyAllowanceLazyStore.deleteProxyAllowance(decodedLog.address, args._owner);
                 // Revalidate orders
                 makerToken = decodedLog.address;
                 makerAddress = args._owner;
-                if (
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress]) &&
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress][makerToken])
-                ) {
+                if (!_.isUndefined(this._dependentOrderHashes[makerAddress]) &&
+                    !_.isUndefined(this._dependentOrderHashes[makerAddress][makerToken])) {
                     const orderHashes = Array.from(this._dependentOrderHashes[makerAddress][makerToken]);
                     await this._emitRevalidateOrdersAsync(orderHashes);
                 }
                 break;
             }
-            case TokenEvents.Transfer: {
+            case TokenEvents.Transfer:
+            {
                 // Invalidate cache
                 const args = decodedLog.args as TransferContractEventArgs;
                 this._balanceAndProxyAllowanceLazyStore.deleteBalance(decodedLog.address, args._from);
@@ -260,48 +190,15 @@ export class OrderStateWatcher {
                 // Revalidate orders
                 makerToken = decodedLog.address;
                 makerAddress = args._from;
-                if (
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress]) &&
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress][makerToken])
-                ) {
+                if (!_.isUndefined(this._dependentOrderHashes[makerAddress]) &&
+                    !_.isUndefined(this._dependentOrderHashes[makerAddress][makerToken])) {
                     const orderHashes = Array.from(this._dependentOrderHashes[makerAddress][makerToken]);
                     await this._emitRevalidateOrdersAsync(orderHashes);
                 }
                 break;
             }
-            case EtherTokenEvents.Deposit: {
-                // Invalidate cache
-                const args = decodedLog.args as DepositContractEventArgs;
-                this._balanceAndProxyAllowanceLazyStore.deleteBalance(decodedLog.address, args._owner);
-                // Revalidate orders
-                makerToken = decodedLog.address;
-                makerAddress = args._owner;
-                if (
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress]) &&
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress][makerToken])
-                ) {
-                    const orderHashes = Array.from(this._dependentOrderHashes[makerAddress][makerToken]);
-                    await this._emitRevalidateOrdersAsync(orderHashes);
-                }
-                break;
-            }
-            case EtherTokenEvents.Withdrawal: {
-                // Invalidate cache
-                const args = decodedLog.args as WithdrawalContractEventArgs;
-                this._balanceAndProxyAllowanceLazyStore.deleteBalance(decodedLog.address, args._owner);
-                // Revalidate orders
-                makerToken = decodedLog.address;
-                makerAddress = args._owner;
-                if (
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress]) &&
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress][makerToken])
-                ) {
-                    const orderHashes = Array.from(this._dependentOrderHashes[makerAddress][makerToken]);
-                    await this._emitRevalidateOrdersAsync(orderHashes);
-                }
-                break;
-            }
-            case ExchangeEvents.LogFill: {
+            case ExchangeEvents.LogFill:
+            {
                 // Invalidate cache
                 const args = decodedLog.args as LogFillContractEventArgs;
                 this._orderFilledCancelledLazyStore.deleteFilledTakerAmount(args.orderHash);
@@ -313,7 +210,8 @@ export class OrderStateWatcher {
                 }
                 break;
             }
-            case ExchangeEvents.LogCancel: {
+            case ExchangeEvents.LogCancel:
+            {
                 // Invalidate cache
                 const args = decodedLog.args as LogCancelContractEventArgs;
                 this._orderFilledCancelledLazyStore.deleteCancelledTakerAmount(args.orderHash);
@@ -334,23 +232,17 @@ export class OrderStateWatcher {
     }
     private async _emitRevalidateOrdersAsync(orderHashes: string[]): Promise<void> {
         for (const orderHash of orderHashes) {
-            const signedOrder = this._orderByOrderHash[orderHash];
+            const signedOrder = this._orderByOrderHash[orderHash] as SignedOrder;
             // Most of these calls will never reach the network because the data is fetched from stores
             // and only updated when cache is invalidated
             const orderState = await this._orderStateUtils.getOrderStateAsync(signedOrder);
             if (_.isUndefined(this._callbackIfExists)) {
                 break; // Unsubscribe was called
             }
-            if (_.isEqual(orderState, this._orderStateByOrderHashCache[orderHash])) {
-                // Actual order state didn't change
-                continue;
-            } else {
-                this._orderStateByOrderHashCache[orderHash] = orderState;
-            }
-            this._callbackIfExists(null, orderState);
+            this._callbackIfExists(orderState);
         }
     }
-    private _addToDependentOrderHashes(signedOrder: SignedOrder, orderHash: string): void {
+    private async addToDependentOrderHashesAsync(signedOrder: SignedOrder, orderHash: string): Promise<void> {
         if (_.isUndefined(this._dependentOrderHashes[signedOrder.maker])) {
             this._dependentOrderHashes[signedOrder.maker] = {};
         }
@@ -358,13 +250,14 @@ export class OrderStateWatcher {
             this._dependentOrderHashes[signedOrder.maker][signedOrder.makerTokenAddress] = new Set();
         }
         this._dependentOrderHashes[signedOrder.maker][signedOrder.makerTokenAddress].add(orderHash);
-        const zrxTokenAddress = this._getZRXTokenAddress();
+        const exchange = (this._orderFilledCancelledLazyStore as any).exchange as ExchangeWrapper;
+        const zrxTokenAddress = await exchange.getZRXTokenAddressAsync();
         if (_.isUndefined(this._dependentOrderHashes[signedOrder.maker][zrxTokenAddress])) {
             this._dependentOrderHashes[signedOrder.maker][zrxTokenAddress] = new Set();
         }
         this._dependentOrderHashes[signedOrder.maker][zrxTokenAddress].add(orderHash);
     }
-    private _removeFromDependentOrderHashes(makerAddress: string, tokenAddress: string, orderHash: string) {
+    private removeFromDependentOrderHashes(makerAddress: string, tokenAddress: string, orderHash: string) {
         this._dependentOrderHashes[makerAddress][tokenAddress].delete(orderHash);
         if (this._dependentOrderHashes[makerAddress][tokenAddress].size === 0) {
             delete this._dependentOrderHashes[makerAddress][tokenAddress];
@@ -373,9 +266,4 @@ export class OrderStateWatcher {
             delete this._dependentOrderHashes[makerAddress];
         }
     }
-    private _getZRXTokenAddress(): string {
-        const exchange = (this._orderFilledCancelledLazyStore as any)._exchange as ExchangeWrapper;
-        const zrxTokenAddress = exchange.getZRXTokenAddress();
-        return zrxTokenAddress;
-    }
 }

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

@@ -1,95 +0,0 @@
-import { SignedOrder } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
-
-export class RemainingFillableCalculator {
-    private _signedOrder: SignedOrder;
-    private _isMakerTokenZRX: boolean;
-    // Transferrable Amount is the minimum of Approval and Balance
-    private _transferrableMakerTokenAmount: BigNumber;
-    private _transferrableMakerFeeTokenAmount: BigNumber;
-    private _remainingMakerTokenAmount: BigNumber;
-    private _remainingMakerFeeAmount: BigNumber;
-    constructor(
-        signedOrder: SignedOrder,
-        isMakerTokenZRX: boolean,
-        transferrableMakerTokenAmount: BigNumber,
-        transferrableMakerFeeTokenAmount: BigNumber,
-        remainingMakerTokenAmount: BigNumber,
-    ) {
-        this._signedOrder = signedOrder;
-        this._isMakerTokenZRX = isMakerTokenZRX;
-        this._transferrableMakerTokenAmount = transferrableMakerTokenAmount;
-        this._transferrableMakerFeeTokenAmount = transferrableMakerFeeTokenAmount;
-        this._remainingMakerTokenAmount = remainingMakerTokenAmount;
-        this._remainingMakerFeeAmount = remainingMakerTokenAmount
-            .times(signedOrder.makerFee)
-            .dividedToIntegerBy(signedOrder.makerTokenAmount);
-    }
-    public computeRemainingMakerFillable(): BigNumber {
-        if (this._hasSufficientFundsForFeeAndTransferAmount()) {
-            return this._remainingMakerTokenAmount;
-        }
-        if (this._signedOrder.makerFee.isZero()) {
-            return BigNumber.min(this._remainingMakerTokenAmount, this._transferrableMakerTokenAmount);
-        }
-        return this._calculatePartiallyFillableMakerTokenAmount();
-    }
-    public computeRemainingTakerFillable(): BigNumber {
-        return this.computeRemainingMakerFillable()
-            .times(this._signedOrder.takerTokenAmount)
-            .dividedToIntegerBy(this._signedOrder.makerTokenAmount);
-    }
-    private _hasSufficientFundsForFeeAndTransferAmount(): boolean {
-        if (this._isMakerTokenZRX) {
-            const totalZRXTransferAmountRequired = this._remainingMakerTokenAmount.plus(this._remainingMakerFeeAmount);
-            const hasSufficientFunds = this._transferrableMakerTokenAmount.greaterThanOrEqualTo(
-                totalZRXTransferAmountRequired,
-            );
-            return hasSufficientFunds;
-        } else {
-            const hasSufficientFundsForTransferAmount = this._transferrableMakerTokenAmount.greaterThanOrEqualTo(
-                this._remainingMakerTokenAmount,
-            );
-            const hasSufficientFundsForFeeAmount = this._transferrableMakerFeeTokenAmount.greaterThanOrEqualTo(
-                this._remainingMakerFeeAmount,
-            );
-            const hasSufficientFunds = hasSufficientFundsForTransferAmount && hasSufficientFundsForFeeAmount;
-            return hasSufficientFunds;
-        }
-    }
-    private _calculatePartiallyFillableMakerTokenAmount(): BigNumber {
-        // Given an order for 200 wei for 2 ZRXwei fee, find 100 wei for 1 ZRXwei. Order ratio is then 100:1
-        const orderToFeeRatio = this._signedOrder.makerTokenAmount.dividedBy(this._signedOrder.makerFee);
-        // The number of times the maker can fill the order, if each fill only required the transfer of a single
-        // baseUnit of fee tokens.
-        // Given 2 ZRXwei, the maximum amount of times Maker can fill this order, in terms of fees, is 2
-        const fillableTimesInFeeTokenBaseUnits = BigNumber.min(
-            this._transferrableMakerFeeTokenAmount,
-            this._remainingMakerFeeAmount,
-        );
-        // The number of times the Maker can fill the order, given the Maker Token Balance
-        // Assuming a balance of 150 wei, and an orderToFeeRatio of 100:1, maker can fill this order 1 time.
-        let fillableTimesInMakerTokenUnits = this._transferrableMakerTokenAmount.dividedBy(orderToFeeRatio);
-        if (this._isMakerTokenZRX) {
-            // If ZRX is the maker token, the Fee and the Maker amount need to be removed from the same pool;
-            // 200 ZRXwei for 2ZRXwei fee can only be filled once (need 202 ZRXwei)
-            const totalZRXTokenPooled = this._transferrableMakerTokenAmount;
-            // The purchasing power here is less as the tokens are taken from the same Pool
-            // For every one number of fills, we have to take an extra ZRX out of the pool
-            fillableTimesInMakerTokenUnits = totalZRXTokenPooled.dividedBy(orderToFeeRatio.plus(new BigNumber(1)));
-        }
-        // When Ratio is not fully divisible there can be remainders which cannot be represented, so they are floored.
-        // This can result in a RoundingError being thrown by the Exchange Contract.
-        const partiallyFillableMakerTokenAmount = fillableTimesInMakerTokenUnits
-            .times(this._signedOrder.makerTokenAmount)
-            .dividedToIntegerBy(this._signedOrder.makerFee);
-        const partiallyFillableFeeTokenAmount = fillableTimesInFeeTokenBaseUnits
-            .times(this._signedOrder.makerTokenAmount)
-            .dividedToIntegerBy(this._signedOrder.makerFee);
-        const partiallyFillableAmount = BigNumber.min(
-            partiallyFillableMakerTokenAmount,
-            partiallyFillableFeeTokenAmount,
-        );
-        return partiallyFillableAmount;
-    }
-}

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

@@ -1,5 +1,23 @@
 export const zeroExConfigSchema = {
     id: '/ZeroExConfig',
-    oneOf: [{ $ref: '/ZeroExPrivateNetworkConfig' }, { $ref: '/ZeroExPublicNetworkConfig' }],
+    properties: {
+        gasPrice: {$ref: '/Number'},
+        exchangeContractAddress: {$ref: '/Address'},
+        tokenRegistryContractAddress: {$ref: '/Address'},
+        etherTokenContractAddress: {$ref: '/Address'},
+        orderWatcherConfig: {
+            type: 'object',
+            properties: {
+                pollingIntervalMs: {
+                    type: 'number',
+                    minimum: 0,
+                },
+                numConfirmations: {
+                    type: 'number',
+                    minimum: 0,
+                },
+            },
+        },
+    },
     type: 'object',
 };

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

@@ -1,35 +0,0 @@
-export const zeroExPrivateNetworkConfigSchema = {
-    id: '/ZeroExPrivateNetworkConfig',
-    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/0x.js/src/schemas/zero_ex_public_network_config_schema.ts

@@ -1,29 +0,0 @@
-export const zeroExPublicNetworkConfigSchema = {
-    id: '/ZeroExPublicNetworkConfig',
-    properties: {
-        networkId: {
-            type: 'number',
-            enum: [1, 3, 4, 42, 50],
-        },
-        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/0x.js/src/stores/balance_proxy_allowance_lazy_store.ts

@@ -1,86 +1,82 @@
-import { BlockParamLiteral } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
-
-import { TokenWrapper } from '../contract_wrappers/token_wrapper';
+import * as Web3 from 'web3';
+import {BigNumber} from 'bignumber.js';
+import {TokenWrapper} from '../contract_wrappers/token_wrapper';
+import {BlockParamLiteral} from '../types';
 
 /**
  * Copy on read store for balances/proxyAllowances of tokens/accounts
  */
 export class BalanceAndProxyAllowanceLazyStore {
-    private _token: TokenWrapper;
-    private _defaultBlock: BlockParamLiteral;
-    private _balance: {
+    private token: TokenWrapper;
+    private balance: {
         [tokenAddress: string]: {
-            [userAddress: string]: BigNumber;
-        };
+            [userAddress: string]: BigNumber,
+        },
     };
-    private _proxyAllowance: {
+    private proxyAllowance: {
         [tokenAddress: string]: {
-            [userAddress: string]: BigNumber;
-        };
+            [userAddress: string]: BigNumber,
+        },
     };
-    constructor(token: TokenWrapper, defaultBlock: BlockParamLiteral) {
-        this._token = token;
-        this._defaultBlock = defaultBlock;
-        this._balance = {};
-        this._proxyAllowance = {};
+    constructor(token: TokenWrapper) {
+        this.token = token;
+        this.balance = {};
+        this.proxyAllowance = {};
     }
     public async getBalanceAsync(tokenAddress: string, userAddress: string): Promise<BigNumber> {
-        if (_.isUndefined(this._balance[tokenAddress]) || _.isUndefined(this._balance[tokenAddress][userAddress])) {
+        if (_.isUndefined(this.balance[tokenAddress]) || _.isUndefined(this.balance[tokenAddress][userAddress])) {
             const methodOpts = {
-                defaultBlock: this._defaultBlock,
+                defaultBlock: BlockParamLiteral.Pending,
             };
-            const balance = await this._token.getBalanceAsync(tokenAddress, userAddress, methodOpts);
+            const balance = await this.token.getBalanceAsync(tokenAddress, userAddress, methodOpts);
             this.setBalance(tokenAddress, userAddress, balance);
         }
-        const cachedBalance = this._balance[tokenAddress][userAddress];
+        const cachedBalance = this.balance[tokenAddress][userAddress];
         return cachedBalance;
     }
     public setBalance(tokenAddress: string, userAddress: string, balance: BigNumber): void {
-        if (_.isUndefined(this._balance[tokenAddress])) {
-            this._balance[tokenAddress] = {};
+        if (_.isUndefined(this.balance[tokenAddress])) {
+            this.balance[tokenAddress] = {};
         }
-        this._balance[tokenAddress][userAddress] = balance;
+        this.balance[tokenAddress][userAddress] = balance;
     }
     public deleteBalance(tokenAddress: string, userAddress: string): void {
-        if (!_.isUndefined(this._balance[tokenAddress])) {
-            delete this._balance[tokenAddress][userAddress];
-            if (_.isEmpty(this._balance[tokenAddress])) {
-                delete this._balance[tokenAddress];
+        if (!_.isUndefined(this.balance[tokenAddress])) {
+            delete this.balance[tokenAddress][userAddress];
+            if (_.isEmpty(this.balance[tokenAddress])) {
+                delete this.balance[tokenAddress];
             }
         }
     }
     public async getProxyAllowanceAsync(tokenAddress: string, userAddress: string): Promise<BigNumber> {
-        if (
-            _.isUndefined(this._proxyAllowance[tokenAddress]) ||
-            _.isUndefined(this._proxyAllowance[tokenAddress][userAddress])
-        ) {
+        if (_.isUndefined(this.proxyAllowance[tokenAddress]) ||
+            _.isUndefined(this.proxyAllowance[tokenAddress][userAddress])) {
             const methodOpts = {
-                defaultBlock: this._defaultBlock,
+                defaultBlock: BlockParamLiteral.Pending,
             };
-            const proxyAllowance = await this._token.getProxyAllowanceAsync(tokenAddress, userAddress, methodOpts);
+            const proxyAllowance = await this.token.getProxyAllowanceAsync(tokenAddress, userAddress, methodOpts);
             this.setProxyAllowance(tokenAddress, userAddress, proxyAllowance);
         }
-        const cachedProxyAllowance = this._proxyAllowance[tokenAddress][userAddress];
+        const cachedProxyAllowance = this.proxyAllowance[tokenAddress][userAddress];
         return cachedProxyAllowance;
     }
     public setProxyAllowance(tokenAddress: string, userAddress: string, proxyAllowance: BigNumber): void {
-        if (_.isUndefined(this._proxyAllowance[tokenAddress])) {
-            this._proxyAllowance[tokenAddress] = {};
+        if (_.isUndefined(this.proxyAllowance[tokenAddress])) {
+            this.proxyAllowance[tokenAddress] = {};
         }
-        this._proxyAllowance[tokenAddress][userAddress] = proxyAllowance;
+        this.proxyAllowance[tokenAddress][userAddress] = proxyAllowance;
     }
     public deleteProxyAllowance(tokenAddress: string, userAddress: string): void {
-        if (!_.isUndefined(this._proxyAllowance[tokenAddress])) {
-            delete this._proxyAllowance[tokenAddress][userAddress];
-            if (_.isEmpty(this._proxyAllowance[tokenAddress])) {
-                delete this._proxyAllowance[tokenAddress];
+        if (!_.isUndefined(this.proxyAllowance[tokenAddress])) {
+            delete this.proxyAllowance[tokenAddress][userAddress];
+            if (_.isEmpty(this.proxyAllowance[tokenAddress])) {
+                delete this.proxyAllowance[tokenAddress];
             }
         }
     }
     public deleteAll(): void {
-        this._balance = {};
-        this._proxyAllowance = {};
+        this.balance = {};
+        this.proxyAllowance = {};
     }
 }

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

@@ -1,61 +1,61 @@
-import { BlockParamLiteral } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
-
-import { ExchangeWrapper } from '../contract_wrappers/exchange_wrapper';
+import * as Web3 from 'web3';
+import {BigNumber} from 'bignumber.js';
+import {ExchangeWrapper} from '../contract_wrappers/exchange_wrapper';
+import {BlockParamLiteral} from '../types';
 
 /**
  * Copy on read store for filled/cancelled taker amounts
  */
 export class OrderFilledCancelledLazyStore {
-    private _exchange: ExchangeWrapper;
-    private _filledTakerAmount: {
-        [orderHash: string]: BigNumber;
+    private exchange: ExchangeWrapper;
+    private filledTakerAmount: {
+        [orderHash: string]: BigNumber,
     };
-    private _cancelledTakerAmount: {
-        [orderHash: string]: BigNumber;
+    private cancelledTakerAmount: {
+        [orderHash: string]: BigNumber,
     };
     constructor(exchange: ExchangeWrapper) {
-        this._exchange = exchange;
-        this._filledTakerAmount = {};
-        this._cancelledTakerAmount = {};
+        this.exchange = exchange;
+        this.filledTakerAmount = {};
+        this.cancelledTakerAmount = {};
     }
     public async getFilledTakerAmountAsync(orderHash: string): Promise<BigNumber> {
-        if (_.isUndefined(this._filledTakerAmount[orderHash])) {
+        if (_.isUndefined(this.filledTakerAmount[orderHash])) {
             const methodOpts = {
                 defaultBlock: BlockParamLiteral.Pending,
             };
-            const filledTakerAmount = await this._exchange.getFilledTakerAmountAsync(orderHash, methodOpts);
+            const filledTakerAmount = await this.exchange.getFilledTakerAmountAsync(orderHash, methodOpts);
             this.setFilledTakerAmount(orderHash, filledTakerAmount);
         }
-        const cachedFilled = this._filledTakerAmount[orderHash];
+        const cachedFilled = this.filledTakerAmount[orderHash];
         return cachedFilled;
     }
     public setFilledTakerAmount(orderHash: string, filledTakerAmount: BigNumber): void {
-        this._filledTakerAmount[orderHash] = filledTakerAmount;
+        this.filledTakerAmount[orderHash] = filledTakerAmount;
     }
     public deleteFilledTakerAmount(orderHash: string): void {
-        delete this._filledTakerAmount[orderHash];
+        delete this.filledTakerAmount[orderHash];
     }
     public async getCancelledTakerAmountAsync(orderHash: string): Promise<BigNumber> {
-        if (_.isUndefined(this._cancelledTakerAmount[orderHash])) {
+        if (_.isUndefined(this.cancelledTakerAmount[orderHash])) {
             const methodOpts = {
                 defaultBlock: BlockParamLiteral.Pending,
             };
-            const cancelledTakerAmount = await this._exchange.getCancelledTakerAmountAsync(orderHash, methodOpts);
+            const cancelledTakerAmount = await this.exchange.getCancelledTakerAmountAsync(orderHash, methodOpts);
             this.setCancelledTakerAmount(orderHash, cancelledTakerAmount);
         }
-        const cachedCancelled = this._cancelledTakerAmount[orderHash];
+        const cachedCancelled = this.cancelledTakerAmount[orderHash];
         return cachedCancelled;
     }
     public setCancelledTakerAmount(orderHash: string, cancelledTakerAmount: BigNumber): void {
-        this._cancelledTakerAmount[orderHash] = cancelledTakerAmount;
+        this.cancelledTakerAmount[orderHash] = cancelledTakerAmount;
     }
     public deleteCancelledTakerAmount(orderHash: string): void {
-        delete this._cancelledTakerAmount[orderHash];
+        delete this.cancelledTakerAmount[orderHash];
     }
     public deleteAll(): void {
-        this._filledTakerAmount = {};
-        this._cancelledTakerAmount = {};
+        this.filledTakerAmount = {};
+        this.cancelledTakerAmount = {};
     }
 }

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

@@ -0,0 +1,24 @@
+import {JSONRPCPayload} from '../types';
+
+/*
+ * This class implements the web3-provider-engine subprovider interface and returns
+ * that the provider has no addresses when queried.
+ * Source: https://github.com/MetaMask/provider-engine/blob/master/subproviders/subprovider.js
+ */
+export class EmptyWalletSubProvider {
+    public handleRequest(payload: JSONRPCPayload, next: () => void, end: (err: Error|null, result: any) => void) {
+        switch (payload.method) {
+            case 'eth_accounts':
+                end(null, []);
+                return;
+
+            default:
+                next();
+                return;
+        }
+    }
+    // Required to implement this method despite not needing it for this subprovider
+    public setEngine(engine: any) {
+        // noop
+    }
+}

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

@@ -1,30 +1,9 @@
-import { BigNumber } from '@0xproject/utils';
-
-import {
-    BlockParam,
-    BlockParamLiteral,
-    ContractAbi,
-    ContractEventArg,
-    FilterObject,
-    LogEntryEvent,
-    LogWithDecodedArgs,
-    Order,
-    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';
+import BigNumber from 'bignumber.js';
 
 export enum ZeroExError {
+    ContractDoesNotExist = 'CONTRACT_DOES_NOT_EXIST',
     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',
@@ -38,26 +17,190 @@ export enum ZeroExError {
     NoNetworkId = 'NO_NETWORK_ID',
     SubscriptionNotFound = 'SUBSCRIPTION_NOT_FOUND',
     SubscriptionAlreadyPresent = 'SUBSCRIPTION_ALREADY_PRESENT',
+    TransactionMiningTimeout = 'TRANSACTION_MINING_TIMEOUT',
 }
 
 export enum InternalZeroExError {
     NoAbiDecoder = 'NO_ABI_DECODER',
     ZrxNotInTokenRegistry = 'ZRX_NOT_IN_TOKEN_REGISTRY',
-    WethNotInTokenRegistry = 'WETH_NOT_IN_TOKEN_REGISTRY',
+}
+
+/**
+ * Elliptic Curve signature
+ */
+export interface ECSignature {
+    v: number;
+    r: string;
+    s: string;
 }
 
 export type OrderAddresses = [string, string, string, string, string];
 
-export type OrderValues = [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber];
+export type OrderValues = [BigNumber, BigNumber, BigNumber,
+                           BigNumber, BigNumber, BigNumber];
 
-export type LogEvent = LogEntryEvent;
-export interface DecodedLogEvent<ArgsType> {
-    isRemoved: boolean;
-    log: LogWithDecodedArgs<ArgsType>;
+export type LogEvent = Web3.LogEntryEvent;
+export type DecodedLogEvent<ArgsType> = Web3.DecodedLogEntryEvent<ArgsType>;
+
+export type EventCallback<ArgsType> = (err: null|Error, log?: DecodedLogEvent<ArgsType>) => void;
+export type EventWatcherCallback = (log: LogEvent) => void;
+
+export interface ExchangeContract extends Web3.ContractInstance {
+    isValidSignature: {
+        callAsync: (signerAddressHex: string, dataHex: string, v: number, r: string, s: string,
+                    txOpts?: TxOpts) => Promise<boolean>;
+    };
+    ZRX_TOKEN_CONTRACT: {
+        callAsync: () => Promise<string>;
+    };
+    TOKEN_TRANSFER_PROXY_CONTRACT: {
+        callAsync: () => Promise<string>;
+    };
+    getUnavailableTakerTokenAmount: {
+        callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber>;
+    };
+    isRoundingError: {
+        callAsync: (takerTokenFillAmount: BigNumber, takerTokenAmount: BigNumber,
+                    makerTokenAmount: BigNumber, txOpts?: TxOpts) => Promise<boolean>;
+    };
+    fillOrder: {
+        sendTransactionAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues,
+                               fillTakerTokenAmount: BigNumber,
+                               shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+                               v: number, r: string, s: string, txOpts?: TxOpts) => Promise<string>;
+        estimateGasAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues,
+                           fillTakerTokenAmount: BigNumber,
+                           shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+                           v: number, r: string, s: string, txOpts?: TxOpts) => Promise<number>;
+    };
+    batchFillOrders: {
+        sendTransactionAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
+                               fillTakerTokenAmounts: BigNumber[],
+                               shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+                               v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise<string>;
+        estimateGasAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
+                           fillTakerTokenAmounts: BigNumber[],
+                           shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+                           v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise<number>;
+    };
+    fillOrdersUpTo: {
+        sendTransactionAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
+                               fillTakerTokenAmount: BigNumber,
+                               shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+                               v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise<string>;
+        estimateGasAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
+                           fillTakerTokenAmount: BigNumber,
+                           shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+                           v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise<number>;
+    };
+    cancelOrder: {
+        sendTransactionAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues,
+                               cancelTakerTokenAmount: BigNumber, txOpts?: TxOpts) => Promise<string>;
+        estimateGasAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues,
+                           cancelTakerTokenAmount: BigNumber,
+                           txOpts?: TxOpts) => Promise<number>;
+    };
+    batchCancelOrders: {
+        sendTransactionAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
+                               cancelTakerTokenAmounts: BigNumber[], txOpts?: TxOpts) => Promise<string>;
+        estimateGasAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
+                           cancelTakerTokenAmounts: BigNumber[],
+                           txOpts?: TxOpts) => Promise<number>;
+    };
+    fillOrKillOrder: {
+        sendTransactionAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues,
+                               fillTakerTokenAmount: BigNumber,
+                               v: number, r: string, s: string, txOpts?: TxOpts) => Promise<string>;
+        estimateGasAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues,
+                           fillTakerTokenAmount: BigNumber,
+                           v: number, r: string, s: string, txOpts?: TxOpts) => Promise<number>;
+    };
+    batchFillOrKillOrders: {
+        sendTransactionAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
+                               fillTakerTokenAmounts: BigNumber[],
+                               v: number[], r: string[], s: string[], txOpts: TxOpts) => Promise<string>;
+        estimateGasAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
+                           fillTakerTokenAmounts: BigNumber[],
+                           v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise<number>;
+    };
+    filled: {
+        callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber>;
+    };
+    cancelled: {
+        callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber>;
+    };
+    getOrderHash: {
+        callAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues) => Promise<string>;
+    };
 }
 
-export type EventCallback<ArgsType> = (err: null | Error, log?: DecodedLogEvent<ArgsType>) => void;
-export type EventWatcherCallback = (err: null | Error, log?: LogEvent) => void;
+export interface TokenContract extends Web3.ContractInstance {
+    balanceOf: {
+        callAsync: (address: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber>;
+    };
+    allowance: {
+        callAsync: (ownerAddress: string, allowedAddress: string,
+                    defaultBlock?: Web3.BlockParam) => Promise<BigNumber>;
+    };
+    transfer: {
+        sendTransactionAsync: (toAddress: string, amountInBaseUnits: BigNumber,
+                               txOpts?: TxOpts) => Promise<string>;
+    };
+    transferFrom: {
+        sendTransactionAsync: (fromAddress: string, toAddress: string, amountInBaseUnits: BigNumber,
+                               txOpts?: TxOpts) => Promise<string>;
+    };
+    approve: {
+        sendTransactionAsync: (proxyAddress: string, amountInBaseUnits: BigNumber,
+                               txOpts?: TxOpts) => Promise<string>;
+    };
+}
+
+export interface TokenRegistryContract extends Web3.ContractInstance {
+    getTokenMetaData: {
+        callAsync: (address: string) => Promise<TokenMetadata>;
+    };
+    getTokenAddresses: {
+        callAsync: () => Promise<string[]>;
+    };
+    getTokenAddressBySymbol: {
+        callAsync: (symbol: string) => Promise<string>;
+    };
+    getTokenAddressByName: {
+        callAsync: (name: string) => Promise<string>;
+    };
+    getTokenBySymbol: {
+        callAsync: (symbol: string) => Promise<TokenMetadata>;
+    };
+    getTokenByName: {
+        callAsync: (name: string) => Promise<TokenMetadata>;
+    };
+}
+
+export interface EtherTokenContract extends Web3.ContractInstance {
+    deposit: {
+        sendTransactionAsync: (txOpts: TxOpts) => Promise<string>;
+    };
+    withdraw: {
+        sendTransactionAsync: (amount: BigNumber, txOpts: TxOpts) => Promise<string>;
+    };
+}
+
+export interface TokenTransferProxyContract extends Web3.ContractInstance {
+    getAuthorizedAddresses: {
+        callAsync: () => Promise<string[]>;
+    };
+    authorized: {
+        callAsync: (address: string) => Promise<boolean>;
+    };
+}
+
+export enum SolidityTypes {
+    Address = 'address',
+    Uint256 = 'uint256',
+    Uint8 = 'uint8',
+    Uint = 'uint',
+}
 
 export enum ExchangeContractErrCodes {
     ERROR_FILL_EXPIRED, // Order has already expired
@@ -93,6 +236,8 @@ export enum ExchangeContractErrs {
     BatchOrdersMustHaveAtLeastOneItem = 'BATCH_ORDERS_MUST_HAVE_AT_LEAST_ONE_ITEM',
 }
 
+export type RawLog = Web3.LogEntry;
+
 export interface ContractEvent {
     logIndex: number;
     transactionIndex: number;
@@ -105,10 +250,69 @@ export interface ContractEvent {
     args: ContractEventArgs;
 }
 
-export type ContractEventArgs = ExchangeContractEventArgs | TokenContractEventArgs | EtherTokenContractEventArgs;
+export interface LogFillContractEventArgs {
+    maker: string;
+    taker: string;
+    feeRecipient: string;
+    makerToken: string;
+    takerToken: string;
+    filledMakerTokenAmount: BigNumber;
+    filledTakerTokenAmount: BigNumber;
+    paidMakerFee: BigNumber;
+    paidTakerFee: BigNumber;
+    tokens: string;
+    orderHash: string;
+}
+export interface LogCancelContractEventArgs {
+    maker: string;
+    feeRecipient: string;
+    makerToken: string;
+    takerToken: string;
+    cancelledMakerTokenAmount: BigNumber;
+    cancelledTakerTokenAmount: BigNumber;
+    tokens: string;
+    orderHash: string;
+}
+export interface LogErrorContractEventArgs {
+    errorId: BigNumber;
+    orderHash: string;
+}
+export type ExchangeContractEventArgs = LogFillContractEventArgs|LogCancelContractEventArgs|LogErrorContractEventArgs;
+export interface TransferContractEventArgs {
+    _from: string;
+    _to: string;
+    _value: BigNumber;
+}
+export interface ApprovalContractEventArgs {
+    _owner: string;
+    _spender: string;
+    _value: BigNumber;
+}
+export type TokenContractEventArgs = TransferContractEventArgs|ApprovalContractEventArgs;
+export type ContractEventArgs = ExchangeContractEventArgs|TokenContractEventArgs;
+export type ContractEventArg = string|BigNumber;
+
+export interface Order {
+    maker: string;
+    taker: string;
+    makerFee: BigNumber;
+    takerFee: BigNumber;
+    makerTokenAmount: BigNumber;
+    takerTokenAmount: BigNumber;
+    makerTokenAddress: string;
+    takerTokenAddress: string;
+    salt: BigNumber;
+    exchangeContractAddress: string;
+    feeRecipient: string;
+    expirationUnixTimestampSec: BigNumber;
+}
+
+export interface SignedOrder extends Order {
+    ecSignature: ECSignature;
+}
 
 //                          [address, name, symbol, decimals, ipfsHash, swarmHash]
-export type TokenMetadata = [string, string, string, number, string, string];
+export type TokenMetadata = [string, string, string, BigNumber, string, string];
 
 export interface Token {
     name: string;
@@ -121,20 +325,38 @@ export interface TxOpts {
     from: string;
     gas?: number;
     value?: BigNumber;
-    gasPrice?: BigNumber;
 }
 
 export interface TokenAddressBySymbol {
     [symbol: string]: string;
 }
 
-export type ContractEvents = TokenEvents | ExchangeEvents | EtherTokenEvents;
+export enum ExchangeEvents {
+    LogFill = 'LogFill',
+    LogCancel = 'LogCancel',
+    LogError = 'LogError',
+}
+
+export enum TokenEvents {
+    Transfer = 'Transfer',
+    Approval = 'Approval',
+}
+
+export type ContractEvents = TokenEvents|ExchangeEvents;
 
 export interface IndexedFilterValues {
     [index: string]: ContractEventArg;
 }
 
-export interface BlockRange {
+export enum BlockParamLiteral {
+    Latest = 'latest',
+    Earliest = 'earliest',
+    Pending = 'pending',
+}
+
+export type BlockParam = BlockParamLiteral|number;
+
+export interface SubscriptionOpts {
     fromBlock: BlockParam;
     toBlock: BlockParam;
 }
@@ -142,7 +364,7 @@ export interface BlockRange {
 export type DoneCallback = (err?: Error) => void;
 
 export interface OrderCancellationRequest {
-    order: Order | SignedOrder;
+    order: Order|SignedOrder;
     takerTokenCancelAmount: BigNumber;
 }
 
@@ -152,61 +374,72 @@ export interface OrderFillRequest {
 }
 
 export type AsyncMethod = (...args: any[]) => Promise<any>;
-export type SyncMethod = (...args: any[]) => any;
 
 /**
  * We re-export the `Web3.Provider` type specified in the Web3 Typescript typings
  * since it is the type of the `provider` argument to the `ZeroEx` constructor.
- * It is however a `Web3` library type, not a native `0x.js` type. To learn more
- * about providers, visit https://0xproject.com/wiki#Web3-Provider-Explained
+ * It is however a `Web3` library type, not a native `0x.js` type.
  */
 export type Web3Provider = Web3.Provider;
 
+export interface ExchangeContractByAddress {
+    [address: string]: ExchangeContract;
+}
+
+export interface JSONRPCPayload {
+    params: any[];
+    method: string;
+}
+
 /*
  * orderExpirationCheckingIntervalMs: How often to check for expired orders. Default: 50
- * eventPollingIntervalMs: How often to poll the Ethereum node for new events. Default: 200
+ * eventPollingIntervalMs: How often to poll the Ethereum node for new events. Defaults: 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. Defaults: 1h
- * stateLayer: Optional blockchain state layer OrderWatcher will monitor for new events. Default: latest
+ * of an orders expiration. Defaults: 0
  */
 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
+ * etherTokenContractAddress: The address of an ether token contract to use
  * orderWatcherConfig: All the configs related to the orderWatcher
  */
 export interface ZeroExConfig {
-    networkId: number;
-    gasPrice?: BigNumber;
+    gasPrice?: BigNumber; // Gas price to use with every transaction
     exchangeContractAddress?: string;
-    zrxContractAddress?: string;
     tokenRegistryContractAddress?: string;
-    tokenTransferProxyContractAddress?: string;
+    etherTokenContractAddress?: string;
     orderWatcherConfig?: OrderStateWatcherConfig;
 }
 
-export type ArtifactContractName = 'ZRX' | 'TokenTransferProxy' | 'TokenRegistry' | 'Token' | 'Exchange' | 'EtherToken';
+export enum AbiType {
+    Function = 'function',
+    Constructor = 'constructor',
+    Event = 'event',
+    Fallback = 'fallback',
+}
+
+export interface DecodedLogArgs {
+    [argName: string]: ContractEventArg;
+}
+
+export interface LogWithDecodedArgs<ArgsType> extends Web3.DecodedLogEntry<ArgsType> {}
+
+export interface TransactionReceiptWithDecodedLogs extends TransactionReceipt {
+    logs: Array<LogWithDecodedArgs<DecodedLogArgs>|Web3.LogEntry>;
+}
 
 export interface Artifact {
-    contract_name: ArtifactContractName;
-    abi: ContractAbi;
-    networks: {
-        [networkId: number]: {
-            address: string;
-        };
-    };
+    abi: any;
+    networks: {[networkId: number]: {
+        address: string;
+    }};
 }
 
 /*
@@ -226,26 +459,19 @@ export interface ValidateOrderFillableOpts {
  * 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;
+    defaultBlock?: Web3.BlockParam;
 }
 
 /*
  * 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
+ * broadcasting it. For example, order has a valid signature, maker has sufficient funds, etc.
  */
-export interface OrderTransactionOpts extends TransactionOpts {
-    shouldValidate?: boolean;
+export interface OrderTransactionOpts {
+    shouldValidate: boolean;
 }
 
+export type FilterObject = Web3.FilterObject;
+
 export enum TradeSide {
     Maker = 'maker',
     Taker = 'taker',
@@ -279,7 +505,20 @@ export interface OrderStateInvalid {
     error: ExchangeContractErrs;
 }
 
-export type OrderState = OrderStateValid | OrderStateInvalid;
+export type OrderState = OrderStateValid|OrderStateInvalid;
 
-export type OnOrderStateChangeCallback = (err: Error | null, orderState?: OrderState) => void;
-// tslint:disable:max-file-line-count
+export type OnOrderStateChangeCallback = (orderState: OrderState) => void;
+
+export interface TransactionReceipt {
+    blockHash: string;
+    blockNumber: number;
+    transactionHash: string;
+    transactionIndex: number;
+    from: string;
+    to: string;
+    status: null|0|1;
+    cumulativeGasUsed: number;
+    gasUsed: number;
+    contractAddress: string|null;
+    logs: Web3.LogEntry[];
+}

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

@@ -0,0 +1,68 @@
+import * as Web3 from 'web3';
+import * as _ from 'lodash';
+import BigNumber from 'bignumber.js';
+import {AbiType, DecodedLogArgs, LogWithDecodedArgs, RawLog, SolidityTypes, ContractEventArgs} from '../types';
+import * as SolidityCoder from 'web3/lib/solidity/coder';
+
+export class AbiDecoder {
+    private savedABIs: Web3.AbiDefinition[] = [];
+    private methodIds: {[signatureHash: string]: Web3.EventAbi} = {};
+    constructor(abiArrays: Web3.AbiDefinition[][]) {
+        _.map(abiArrays, this.addABI.bind(this));
+    }
+    // This method can only decode logs from the 0x & ERC20 smart contracts
+    public tryToDecodeLogOrNoop<ArgsType extends ContractEventArgs>(
+        log: Web3.LogEntry): LogWithDecodedArgs<ArgsType>|RawLog {
+        const methodId = log.topics[0];
+        const event = this.methodIds[methodId];
+        if (_.isUndefined(event)) {
+            return log;
+        }
+        const logData = log.data;
+        const decodedParams: DecodedLogArgs = {};
+        let dataIndex = 0;
+        let topicsIndex = 1;
+
+        const nonIndexedInputs = _.filter(event.inputs, input => !input.indexed);
+        const dataTypes = _.map(nonIndexedInputs, input => input.type);
+        const decodedData = SolidityCoder.decodeParams(dataTypes, logData.slice('0x'.length));
+
+        _.map(event.inputs, (param: Web3.EventParameter) => {
+            // Indexed parameters are stored in topics. Non-indexed ones in decodedData
+            let value = param.indexed ? log.topics[topicsIndex++] : decodedData[dataIndex++];
+            if (param.type === SolidityTypes.Address) {
+                value = this.padZeros(new BigNumber(value).toString(16));
+            } else if (param.type === SolidityTypes.Uint256 ||
+                       param.type === SolidityTypes.Uint8 ||
+                       param.type === SolidityTypes.Uint) {
+                value = new BigNumber(value);
+            }
+            decodedParams[param.name] = value;
+        });
+
+        return {
+            ...log,
+            event: event.name,
+            args: decodedParams,
+        };
+    }
+    private addABI(abiArray: Web3.AbiDefinition[]): void {
+        _.map(abiArray, (abi: Web3.AbiDefinition) => {
+            if (abi.type === AbiType.Event) {
+                const signature = `${abi.name}(${_.map(abi.inputs, input => input.type).join(',')})`;
+                const signatureHash = new Web3().sha3(signature);
+                this.methodIds[signatureHash] = abi;
+            }
+        });
+        this.savedABIs = this.savedABIs.concat(abiArray);
+    }
+    private padZeros(address: string) {
+        let formatted = address;
+        if (_.startsWith(formatted, '0x')) {
+            formatted = formatted.slice(2);
+        }
+
+        formatted = _.padStart(formatted, 40, '0');
+        return `0x${formatted}`;
+    }
+}

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

@@ -1,14 +1,13 @@
-import { assert as sharedAssert } from '@0xproject/assert';
-// We need those two unused imports because they're actually used by sharedAssert which gets injected here
-// tslint:disable-next-line:no-unused-variable
-import { Schema } from '@0xproject/json-schemas';
-// tslint:disable-next-line:no-unused-variable
-import { ECSignature } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
+import * as Web3 from 'web3';
+import BigNumber from 'bignumber.js';
+import {SchemaValidator, Schema} from '@0xproject/json-schemas';
+import {assert as sharedAssert} from '@0xproject/assert';
+import {Web3Wrapper} from '../web3_wrapper';
+import {signatureUtils} from '../utils/signature_utils';
+import {ECSignature} from '../types';
 
-import { signatureUtils } from '../utils/signature_utils';
+const HEX_REGEX = /^0x[0-9A-F]*$/i;
 
 export const assert = {
     ...sharedAssert,
@@ -16,15 +15,11 @@ export const assert = {
         const isValidSignature = signatureUtils.isValidSignature(orderHash, ecSignature, signerAddress);
         this.assert(isValidSignature, `Expected order with hash '${orderHash}' to have a valid signature`);
     },
-    async isSenderAddressAsync(
-        variableName: string,
-        senderAddressHex: string,
-        web3Wrapper: Web3Wrapper,
-    ): Promise<void> {
+    async isSenderAddressAsync(variableName: string, senderAddressHex: string,
+                               web3Wrapper: Web3Wrapper): Promise<void> {
         sharedAssert.isETHAddressHex(variableName, senderAddressHex);
         const isSenderAddressAvailable = await web3Wrapper.isSenderAddressAvailableAsync(senderAddressHex);
-        sharedAssert.assert(
-            isSenderAddressAvailable,
+        sharedAssert.assert(isSenderAddressAvailable,
             `Specified ${variableName} ${senderAddressHex} isn't available through the supplied web3 provider`,
         );
     },

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

@@ -1,4 +1,4 @@
-import { BigNumber } from '@0xproject/utils';
+import BigNumber from 'bignumber.js';
 
 export const constants = {
     NULL_ADDRESS: '0x0000000000000000000000000000000000000000',
@@ -6,7 +6,6 @@ export const constants = {
     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/decorators.ts

@@ -1,91 +1,35 @@
 import * as _ from 'lodash';
+import {constants} from './constants';
+import {AsyncMethod, ZeroExError} from '../types';
 
-import { AsyncMethod, SyncMethod, ZeroExError } from '../types';
-
-import { constants } from './constants';
-
-type ErrorTransformer = (err: Error) => Error;
-
-const contractCallErrorTransformer = (error: Error) => {
-    if (_.includes(error.message, constants.INVALID_JUMP_PATTERN)) {
-        return new Error(ZeroExError.InvalidJump);
-    }
-    if (_.includes(error.message, constants.OUT_OF_GAS_PATTERN)) {
-        return new Error(ZeroExError.OutOfGas);
-    }
-    return error;
-};
-
-const schemaErrorTransformer = (error: Error) => {
-    if (_.includes(error.message, constants.INVALID_TAKER_FORMAT)) {
-        const errMsg =
-            'Order taker must be of type string. If you want anyone to be able to fill an order - pass ZeroEx.NULL_ADDRESS';
-        return new Error(errMsg);
-    }
-    return error;
-};
-
-/**
- * Source: https://stackoverflow.com/a/29837695/3546986
- */
-const asyncErrorHandlerFactory = (errorTransformer: ErrorTransformer) => {
-    const asyncErrorHandlingDecorator = (
-        target: object,
-        key: string | symbol,
-        descriptor: TypedPropertyDescriptor<AsyncMethod>,
-    ) => {
-        const originalMethod = descriptor.value as AsyncMethod;
+export const decorators = {
+    /**
+     * Source: https://stackoverflow.com/a/29837695/3546986
+     */
+    contractCallErrorHandler(target: object,
+                             key: string|symbol,
+                             descriptor: TypedPropertyDescriptor<AsyncMethod>,
+    ): TypedPropertyDescriptor<AsyncMethod> {
+        const originalMethod = (descriptor.value as AsyncMethod);
 
         // 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[]) {
             try {
                 const result = await originalMethod.apply(this, args);
                 return result;
             } catch (error) {
-                const transformedError = errorTransformer(error);
-                throw transformedError;
+                if (_.includes(error.message, constants.INVALID_JUMP_PATTERN)) {
+                    throw new Error(ZeroExError.InvalidJump);
+                }
+                if (_.includes(error.message, constants.OUT_OF_GAS_PATTERN)) {
+                    throw new Error(ZeroExError.OutOfGas);
+                }
+                throw error;
             }
         };
 
         return descriptor;
-    };
-
-    return asyncErrorHandlingDecorator;
-};
-
-const syncErrorHandlerFactory = (errorTransformer: ErrorTransformer) => {
-    const syncErrorHandlingDecorator = (
-        target: object,
-        key: string | symbol,
-        descriptor: TypedPropertyDescriptor<SyncMethod>,
-    ) => {
-        const originalMethod = descriptor.value as SyncMethod;
-
-        // 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[]) {
-            try {
-                const result = originalMethod.apply(this, args);
-                return result;
-            } catch (error) {
-                const transformedError = errorTransformer(error);
-                throw transformedError;
-            }
-        };
-
-        return descriptor;
-    };
-
-    return syncErrorHandlingDecorator;
-};
-
-// _.flow(f, g) = f ∘ g
-const zeroExErrorTransformer = _.flow(schemaErrorTransformer, contractCallErrorTransformer);
-
-export const decorators = {
-    asyncZeroExErrorHandler: asyncErrorHandlerFactory(zeroExErrorTransformer),
-    syncZeroExErrorHandler: syncErrorHandlerFactory(zeroExErrorTransformer),
+    },
 };

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

@@ -1,10 +1,8 @@
-import { BlockParamLiteral } 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 BigNumber from 'bignumber.js';
+import {ExchangeContractErrs, TradeSide, TransferType, BlockParamLiteral} from '../types';
+import {TokenWrapper} from '../contract_wrappers/token_wrapper';
+import {BalanceAndProxyAllowanceLazyStore} from '../stores/balance_proxy_allowance_lazy_store';
 
 enum FailureReason {
     Balance = 'balance',
@@ -35,19 +33,11 @@ const ERR_MSG_MAPPING = {
 };
 
 export class ExchangeTransferSimulator {
-    private _store: BalanceAndProxyAllowanceLazyStore;
-    private _UNLIMITED_ALLOWANCE_IN_BASE_UNITS: BigNumber;
-    private static _throwValidationError(
-        failureReason: FailureReason,
-        tradeSide: TradeSide,
-        transferType: TransferType,
-    ): never {
-        const errMsg = ERR_MSG_MAPPING[failureReason][tradeSide][transferType];
-        throw new Error(errMsg);
-    }
-    constructor(token: TokenWrapper, defaultBlock: BlockParamLiteral) {
-        this._store = new BalanceAndProxyAllowanceLazyStore(token, defaultBlock);
-        this._UNLIMITED_ALLOWANCE_IN_BASE_UNITS = token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
+    private store: BalanceAndProxyAllowanceLazyStore;
+    private UNLIMITED_ALLOWANCE_IN_BASE_UNITS: BigNumber;
+    constructor(token: TokenWrapper) {
+        this.store = new BalanceAndProxyAllowanceLazyStore(token);
+        this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS = token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
     }
     /**
      * Simulates transferFrom call performed by a proxy
@@ -58,50 +48,41 @@ export class ExchangeTransferSimulator {
      * @param  tradeSide         Is Maker/Taker transferring
      * @param  transferType      Is it a fee payment or a value transfer
      */
-    public async transferFromAsync(
-        tokenAddress: string,
-        from: string,
-        to: string,
-        amountInBaseUnits: BigNumber,
-        tradeSide: TradeSide,
-        transferType: TransferType,
-    ): Promise<void> {
-        const balance = await this._store.getBalanceAsync(tokenAddress, from);
-        const proxyAllowance = await this._store.getProxyAllowanceAsync(tokenAddress, from);
+    public async transferFromAsync(tokenAddress: string, from: string, to: string,
+                                   amountInBaseUnits: BigNumber, tradeSide: TradeSide,
+                                   transferType: TransferType): Promise<void> {
+        const balance = await this.store.getBalanceAsync(tokenAddress, from);
+        const proxyAllowance = await this.store.getProxyAllowanceAsync(tokenAddress, from);
         if (proxyAllowance.lessThan(amountInBaseUnits)) {
-            ExchangeTransferSimulator._throwValidationError(FailureReason.ProxyAllowance, tradeSide, transferType);
+            this.throwValidationError(FailureReason.ProxyAllowance, tradeSide, transferType);
         }
         if (balance.lessThan(amountInBaseUnits)) {
-            ExchangeTransferSimulator._throwValidationError(FailureReason.Balance, tradeSide, transferType);
+            this.throwValidationError(FailureReason.Balance, tradeSide, transferType);
         }
-        await this._decreaseProxyAllowanceAsync(tokenAddress, from, amountInBaseUnits);
-        await this._decreaseBalanceAsync(tokenAddress, from, amountInBaseUnits);
-        await this._increaseBalanceAsync(tokenAddress, to, amountInBaseUnits);
+        await this.decreaseProxyAllowanceAsync(tokenAddress, from, amountInBaseUnits);
+        await this.decreaseBalanceAsync(tokenAddress, from, amountInBaseUnits);
+        await this.increaseBalanceAsync(tokenAddress, to, amountInBaseUnits);
     }
-    private async _decreaseProxyAllowanceAsync(
-        tokenAddress: string,
-        userAddress: string,
-        amountInBaseUnits: BigNumber,
-    ): Promise<void> {
-        const proxyAllowance = await this._store.getProxyAllowanceAsync(tokenAddress, userAddress);
-        if (!proxyAllowance.eq(this._UNLIMITED_ALLOWANCE_IN_BASE_UNITS)) {
-            this._store.setProxyAllowance(tokenAddress, userAddress, proxyAllowance.minus(amountInBaseUnits));
+    private async decreaseProxyAllowanceAsync(tokenAddress: string, userAddress: string,
+                                              amountInBaseUnits: BigNumber): Promise<void> {
+        const proxyAllowance = await this.store.getProxyAllowanceAsync(tokenAddress, userAddress);
+        if (!proxyAllowance.eq(this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS)) {
+            this.store.setProxyAllowance(tokenAddress, userAddress, proxyAllowance.minus(amountInBaseUnits));
         }
     }
-    private async _increaseBalanceAsync(
-        tokenAddress: string,
-        userAddress: string,
-        amountInBaseUnits: BigNumber,
-    ): Promise<void> {
-        const balance = await this._store.getBalanceAsync(tokenAddress, userAddress);
-        this._store.setBalance(tokenAddress, userAddress, balance.plus(amountInBaseUnits));
+    private async increaseBalanceAsync(tokenAddress: string, userAddress: string,
+                                       amountInBaseUnits: BigNumber): Promise<void> {
+        const balance = await this.store.getBalanceAsync(tokenAddress, userAddress);
+        this.store.setBalance(tokenAddress, userAddress, balance.plus(amountInBaseUnits));
     }
-    private async _decreaseBalanceAsync(
-        tokenAddress: string,
-        userAddress: string,
-        amountInBaseUnits: BigNumber,
-    ): Promise<void> {
-        const balance = await this._store.getBalanceAsync(tokenAddress, userAddress);
-        this._store.setBalance(tokenAddress, userAddress, balance.minus(amountInBaseUnits));
+    private async decreaseBalanceAsync(tokenAddress: string, userAddress: string,
+                                       amountInBaseUnits: BigNumber): Promise<void> {
+        const balance = await this.store.getBalanceAsync(tokenAddress, userAddress);
+        this.store.setBalance(tokenAddress, userAddress, balance.minus(amountInBaseUnits));
+    }
+    private throwValidationError(failureReason: FailureReason, tradeSide: TradeSide,
+                                 transferType: TransferType): Promise<never> {
+        const errMsg = ERR_MSG_MAPPING[failureReason][tradeSide][transferType];
+        throw new Error(errMsg);
     }
 }

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

@@ -1,18 +1,9 @@
-import {
-    ConstructorAbi,
-    ContractAbi,
-    EventAbi,
-    FallbackAbi,
-    FilterObject,
-    LogEntry,
-    MethodAbi,
-} from '@0xproject/types';
+import * as _ from 'lodash';
+import * as Web3 from 'web3';
+import * as uuid from 'uuid/v4';
 import * as ethUtil from 'ethereumjs-util';
 import * as jsSHA3 from 'js-sha3';
-import * as _ from 'lodash';
-import * as uuid from 'uuid/v4';
-
-import { BlockRange, ContractEvents, IndexedFilterValues } from '../types';
+import {ContractEvents, IndexedFilterValues, SubscriptionOpts} from '../types';
 
 const TOPIC_LENGTH = 32;
 
@@ -20,37 +11,33 @@ export const filterUtils = {
     generateUUID(): string {
         return uuid();
     },
-    getFilter(
-        address: string,
-        eventName: ContractEvents,
-        indexFilterValues: IndexedFilterValues,
-        abi: ContractAbi,
-        blockRange?: BlockRange,
-    ): FilterObject {
-        const eventAbi = _.find(abi, { name: eventName }) as EventAbi;
+    getFilter(address: string, eventName: ContractEvents,
+              indexFilterValues: IndexedFilterValues, abi: Web3.ContractAbi,
+              subscriptionOpts?: SubscriptionOpts): Web3.FilterObject {
+        const eventAbi = _.find(abi, {name: eventName}) as Web3.EventAbi;
         const eventSignature = filterUtils.getEventSignatureFromAbiByName(eventAbi, eventName);
         const topicForEventSignature = ethUtil.addHexPrefix(jsSHA3.keccak256(eventSignature));
         const topicsForIndexedArgs = filterUtils.getTopicsForIndexedArgs(eventAbi, indexFilterValues);
         const topics = [topicForEventSignature, ...topicsForIndexedArgs];
-        let filter: FilterObject = {
+        let filter: Web3.FilterObject = {
             address,
             topics,
         };
-        if (!_.isUndefined(blockRange)) {
+        if (!_.isUndefined(subscriptionOpts)) {
             filter = {
-                ...blockRange,
+                ...subscriptionOpts,
                 ...filter,
             };
         }
         return filter;
     },
-    getEventSignatureFromAbiByName(eventAbi: EventAbi, eventName: ContractEvents): string {
+    getEventSignatureFromAbiByName(eventAbi: Web3.EventAbi, eventName: ContractEvents): string {
         const types = _.map(eventAbi.inputs, 'type');
         const signature = `${eventAbi.name}(${types.join(',')})`;
         return signature;
     },
-    getTopicsForIndexedArgs(abi: EventAbi, indexFilterValues: IndexedFilterValues): Array<string | null> {
-        const topics: Array<string | null> = [];
+    getTopicsForIndexedArgs(abi: Web3.EventAbi, indexFilterValues: IndexedFilterValues): Array<string|null> {
+        const topics: Array<string|null> = [];
         for (const eventInput of abi.inputs) {
             if (!eventInput.indexed) {
                 continue;
@@ -68,7 +55,7 @@ export const filterUtils = {
         }
         return topics;
     },
-    matchesFilter(log: LogEntry, filter: FilterObject): boolean {
+    matchesFilter(log: Web3.LogEntry, filter: Web3.FilterObject): boolean {
         if (!_.isUndefined(filter.address) && log.address !== filter.address) {
             return false;
         }
@@ -77,12 +64,12 @@ export const filterUtils = {
         }
         return true;
     },
-    matchesTopics(logTopics: string[], filterTopics: Array<string[] | string | null>): boolean {
+    matchesTopics(logTopics: string[], filterTopics: Array<string[]|string|null>): boolean {
         const matchesTopic = _.zipWith(logTopics, filterTopics, filterUtils.matchesTopic.bind(filterUtils));
         const matchesTopics = _.every(matchesTopic);
         return matchesTopics;
     },
-    matchesTopic(logTopic: string, filterTopic: string[] | string | null): boolean {
+    matchesTopic(logTopic: string, filterTopic: string[]|string|null): boolean {
         if (_.isArray(filterTopic)) {
             return _.includes(filterTopic, logTopic);
         }

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

@@ -0,0 +1,20 @@
+import * as _ from 'lodash';
+
+export const intervalUtils = {
+    setAsyncExcludingInterval(fn: () => Promise<void>, intervalMs: number) {
+        let locked = false;
+        const intervalId = setInterval(async () => {
+            if (locked) {
+                return;
+            } else {
+                locked = true;
+                await fn();
+                locked = false;
+            }
+        }, intervalMs);
+        return intervalId;
+    },
+    clearAsyncExcludingInterval(intervalId: NodeJS.Timer): void {
+        clearInterval(intervalId);
+    },
+};

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

@@ -1,20 +1,102 @@
-import { 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 { RemainingFillableCalculator } from '../order_watcher/remaining_fillable_calculator';
-import { BalanceAndProxyAllowanceLazyStore } from '../stores/balance_proxy_allowance_lazy_store';
-import { OrderFilledCancelledLazyStore } from '../stores/order_filled_cancelled_lazy_store';
-import { ExchangeContractErrs, OrderRelevantState, OrderState, OrderStateInvalid, OrderStateValid } from '../types';
+import * as Web3 from 'web3';
+import BigNumber from 'bignumber.js';
+import {
+    ExchangeContractErrs,
+    SignedOrder,
+    OrderRelevantState,
+    MethodOpts,
+    OrderState,
+    OrderStateValid,
+    OrderStateInvalid,
+} from '../types';
+import {ZeroEx} from '../0x';
+import {TokenWrapper} from '../contract_wrappers/token_wrapper';
+import {ExchangeWrapper} from '../contract_wrappers/exchange_wrapper';
+import {utils} from '../utils/utils';
+import {constants} from '../utils/constants';
+import {OrderFilledCancelledLazyStore} from '../stores/order_filled_cancelled_lazy_store';
+import {BalanceAndProxyAllowanceLazyStore} from '../stores/balance_proxy_allowance_lazy_store';
 
 const ACCEPTABLE_RELATIVE_ROUNDING_ERROR = 0.0001;
 
 export class OrderStateUtils {
-    private _balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore;
-    private _orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore;
-    private static _validateIfOrderIsValid(signedOrder: SignedOrder, orderRelevantState: OrderRelevantState): void {
+    private balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore;
+    private orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore;
+    constructor(balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore,
+                orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore) {
+        this.balanceAndProxyAllowanceLazyStore = balanceAndProxyAllowanceLazyStore;
+        this.orderFilledCancelledLazyStore = orderFilledCancelledLazyStore;
+    }
+    public async getOrderStateAsync(signedOrder: SignedOrder): Promise<OrderState> {
+        const orderRelevantState = await this.getOrderRelevantStateAsync(signedOrder);
+        const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+        try {
+            this.validateIfOrderIsValid(signedOrder, orderRelevantState);
+            const orderState: OrderStateValid = {
+                isValid: true,
+                orderHash,
+                orderRelevantState,
+            };
+            return orderState;
+        } catch (err) {
+            const orderState: OrderStateInvalid = {
+                isValid: false,
+                orderHash,
+                error: err.message,
+            };
+            return orderState;
+        }
+    }
+    public async getOrderRelevantStateAsync(signedOrder: SignedOrder): Promise<OrderRelevantState> {
+        // HACK: We access the private property here but otherwise the interface will be less nice.
+        // If we pass it from the instantiator - there is no opportunity to get it there
+        // because JS doesn't support async constructors.
+        // Moreover - it's cached under the hood so it's equivalent to an async constructor.
+        const exchange = (this.orderFilledCancelledLazyStore as any).exchange as ExchangeWrapper;
+        const zrxTokenAddress = await exchange.getZRXTokenAddressAsync();
+        const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+        const makerBalance = await this.balanceAndProxyAllowanceLazyStore.getBalanceAsync(
+            signedOrder.makerTokenAddress, signedOrder.maker,
+        );
+        const makerProxyAllowance = await this.balanceAndProxyAllowanceLazyStore.getProxyAllowanceAsync(
+            signedOrder.makerTokenAddress, signedOrder.maker,
+        );
+        const makerFeeBalance = await this.balanceAndProxyAllowanceLazyStore.getBalanceAsync(
+            zrxTokenAddress, signedOrder.maker,
+        );
+        const makerFeeProxyAllowance = await this.balanceAndProxyAllowanceLazyStore.getProxyAllowanceAsync(
+            zrxTokenAddress, signedOrder.maker,
+        );
+        const filledTakerTokenAmount = await this.orderFilledCancelledLazyStore.getFilledTakerAmountAsync(orderHash);
+        const cancelledTakerTokenAmount = await this.orderFilledCancelledLazyStore.getCancelledTakerAmountAsync(
+            orderHash,
+        );
+        const unavailableTakerTokenAmount = await exchange.getUnavailableTakerAmountAsync(orderHash);
+        const totalMakerTokenAmount = signedOrder.makerTokenAmount;
+        const totalTakerTokenAmount = signedOrder.takerTokenAmount;
+        const remainingTakerTokenAmount = totalTakerTokenAmount.minus(unavailableTakerTokenAmount);
+        const remainingMakerTokenAmount = remainingTakerTokenAmount.times(totalMakerTokenAmount)
+                                                                   .dividedToIntegerBy(totalTakerTokenAmount);
+        const fillableMakerTokenAmount = BigNumber.min([makerProxyAllowance, makerBalance]);
+        const remainingFillableMakerTokenAmount = BigNumber.min(fillableMakerTokenAmount, remainingMakerTokenAmount);
+        const remainingFillableTakerTokenAmount = remainingFillableMakerTokenAmount
+                                                  .times(totalTakerTokenAmount)
+                                                  .dividedToIntegerBy(totalMakerTokenAmount);
+        // TODO: Handle edge case where maker token is ZRX with fee
+        const orderRelevantState = {
+            makerBalance,
+            makerProxyAllowance,
+            makerFeeBalance,
+            makerFeeProxyAllowance,
+            filledTakerTokenAmount,
+            cancelledTakerTokenAmount,
+            remainingFillableMakerTokenAmount,
+            remainingFillableTakerTokenAmount,
+        };
+        return orderRelevantState;
+    }
+    private validateIfOrderIsValid(signedOrder: SignedOrder, orderRelevantState: OrderRelevantState): void {
         const unavailableTakerTokenAmount = orderRelevantState.cancelledTakerTokenAmount.add(
             orderRelevantState.filledTakerTokenAmount,
         );
@@ -38,101 +120,13 @@ export class OrderStateUtils {
             }
         }
         const minFillableTakerTokenAmountWithinNoRoundingErrorRange = signedOrder.takerTokenAmount
-            .dividedBy(ACCEPTABLE_RELATIVE_ROUNDING_ERROR)
-            .dividedBy(signedOrder.makerTokenAmount);
-        if (
-            orderRelevantState.remainingFillableTakerTokenAmount.lessThan(
-                minFillableTakerTokenAmountWithinNoRoundingErrorRange,
-            )
-        ) {
+                                                                      .dividedBy(ACCEPTABLE_RELATIVE_ROUNDING_ERROR)
+                                                                      .dividedBy(signedOrder.makerTokenAmount);
+        if (orderRelevantState.remainingFillableTakerTokenAmount
+            .lessThan(minFillableTakerTokenAmountWithinNoRoundingErrorRange)) {
             throw new Error(ExchangeContractErrs.OrderFillRoundingError);
         }
-    }
-    constructor(
-        balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore,
-        orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore,
-    ) {
-        this._balanceAndProxyAllowanceLazyStore = balanceAndProxyAllowanceLazyStore;
-        this._orderFilledCancelledLazyStore = orderFilledCancelledLazyStore;
-    }
-    public async getOrderStateAsync(signedOrder: SignedOrder): Promise<OrderState> {
-        const orderRelevantState = await this.getOrderRelevantStateAsync(signedOrder);
-        const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-        try {
-            OrderStateUtils._validateIfOrderIsValid(signedOrder, orderRelevantState);
-            const orderState: OrderStateValid = {
-                isValid: true,
-                orderHash,
-                orderRelevantState,
-            };
-            return orderState;
-        } catch (err) {
-            const orderState: OrderStateInvalid = {
-                isValid: false,
-                orderHash,
-                error: err.message,
-            };
-            return orderState;
-        }
-    }
-    public async getOrderRelevantStateAsync(signedOrder: SignedOrder): Promise<OrderRelevantState> {
-        // HACK: We access the private property here but otherwise the interface will be less nice.
-        // If we pass it from the instantiator - there is no opportunity to get it there
-        // because JS doesn't support async constructors.
-        // Moreover - it's cached under the hood so it's equivalent to an async constructor.
-        const exchange = (this._orderFilledCancelledLazyStore as any)._exchange as ExchangeWrapper;
-        const zrxTokenAddress = exchange.getZRXTokenAddress();
-        const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-        const makerBalance = await this._balanceAndProxyAllowanceLazyStore.getBalanceAsync(
-            signedOrder.makerTokenAddress,
-            signedOrder.maker,
-        );
-        const makerProxyAllowance = await this._balanceAndProxyAllowanceLazyStore.getProxyAllowanceAsync(
-            signedOrder.makerTokenAddress,
-            signedOrder.maker,
-        );
-        const makerFeeBalance = await this._balanceAndProxyAllowanceLazyStore.getBalanceAsync(
-            zrxTokenAddress,
-            signedOrder.maker,
-        );
-        const makerFeeProxyAllowance = await this._balanceAndProxyAllowanceLazyStore.getProxyAllowanceAsync(
-            zrxTokenAddress,
-            signedOrder.maker,
-        );
-        const filledTakerTokenAmount = await this._orderFilledCancelledLazyStore.getFilledTakerAmountAsync(orderHash);
-        const cancelledTakerTokenAmount = await this._orderFilledCancelledLazyStore.getCancelledTakerAmountAsync(
-            orderHash,
-        );
-        const unavailableTakerTokenAmount = await exchange.getUnavailableTakerAmountAsync(orderHash);
-        const totalMakerTokenAmount = signedOrder.makerTokenAmount;
-        const totalTakerTokenAmount = signedOrder.takerTokenAmount;
-        const remainingTakerTokenAmount = totalTakerTokenAmount.minus(unavailableTakerTokenAmount);
-        const remainingMakerTokenAmount = remainingTakerTokenAmount
-            .times(totalMakerTokenAmount)
-            .dividedToIntegerBy(totalTakerTokenAmount);
-        const transferrableMakerTokenAmount = BigNumber.min([makerProxyAllowance, makerBalance]);
-        const transferrableFeeTokenAmount = BigNumber.min([makerFeeProxyAllowance, makerFeeBalance]);
-
-        const isMakerTokenZRX = signedOrder.makerTokenAddress === zrxTokenAddress;
-        const remainingFillableCalculator = new RemainingFillableCalculator(
-            signedOrder,
-            isMakerTokenZRX,
-            transferrableMakerTokenAmount,
-            transferrableFeeTokenAmount,
-            remainingMakerTokenAmount,
-        );
-        const remainingFillableMakerTokenAmount = remainingFillableCalculator.computeRemainingMakerFillable();
-        const remainingFillableTakerTokenAmount = remainingFillableCalculator.computeRemainingTakerFillable();
-        const orderRelevantState = {
-            makerBalance,
-            makerProxyAllowance,
-            makerFeeBalance,
-            makerFeeProxyAllowance,
-            filledTakerTokenAmount,
-            cancelledTakerTokenAmount,
-            remainingFillableMakerTokenAmount,
-            remainingFillableTakerTokenAmount,
-        };
-        return orderRelevantState;
+        // TODO Add linear function solver when maker token is ZRX #badass
+        // Return the max amount that's fillable
     }
 }

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

@@ -1,22 +1,101 @@
-import { 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 { constants } from '../utils/constants';
-import { utils } from '../utils/utils';
-
-import { ExchangeTransferSimulator } from './exchange_transfer_simulator';
+import BigNumber from 'bignumber.js';
+import {ExchangeContractErrs, SignedOrder, Order, ZeroExError, TradeSide, TransferType} from '../types';
+import {ZeroEx} from '../0x';
+import {TokenWrapper} from '../contract_wrappers/token_wrapper';
+import {ExchangeWrapper} from '../contract_wrappers/exchange_wrapper';
+import {utils} from '../utils/utils';
+import {constants} from '../utils/constants';
+import {ExchangeTransferSimulator} from './exchange_transfer_simulator';
 
 export class OrderValidationUtils {
-    private _exchangeWrapper: ExchangeWrapper;
-    public static validateCancelOrderThrowIfInvalid(
-        order: Order,
-        cancelTakerTokenAmount: BigNumber,
-        unavailableTakerTokenAmount: BigNumber,
-    ): void {
+    private tokenWrapper: TokenWrapper;
+    private exchangeWrapper: ExchangeWrapper;
+    constructor(tokenWrapper: TokenWrapper, exchangeWrapper: ExchangeWrapper) {
+        this.tokenWrapper = tokenWrapper;
+        this.exchangeWrapper = exchangeWrapper;
+    }
+    public async validateOrderFillableOrThrowAsync(
+        exchangeTradeEmulator: ExchangeTransferSimulator, signedOrder: SignedOrder, zrxTokenAddress: string,
+        expectedFillTakerTokenAmount?: BigNumber): Promise<void> {
+        const orderHash = utils.getOrderHashHex(signedOrder);
+        const unavailableTakerTokenAmount = await this.exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
+        this.validateRemainingFillAmountNotZeroOrThrow(
+            signedOrder.takerTokenAmount, unavailableTakerTokenAmount,
+        );
+        this.validateOrderNotExpiredOrThrow(signedOrder.expirationUnixTimestampSec);
+        let fillTakerTokenAmount = signedOrder.takerTokenAmount.minus(unavailableTakerTokenAmount);
+        if (!_.isUndefined(expectedFillTakerTokenAmount)) {
+            fillTakerTokenAmount = expectedFillTakerTokenAmount;
+        }
+        const fillMakerTokenAmount = this.getPartialAmount(
+            fillTakerTokenAmount,
+            signedOrder.takerTokenAmount,
+            signedOrder.makerTokenAmount,
+        );
+        await exchangeTradeEmulator.transferFromAsync(
+            signedOrder.makerTokenAddress, signedOrder.maker, signedOrder.taker, fillMakerTokenAmount,
+            TradeSide.Maker, TransferType.Trade,
+        );
+        const makerFeeAmount = this.getPartialAmount(
+            fillTakerTokenAmount,
+            signedOrder.takerTokenAmount,
+            signedOrder.makerFee,
+        );
+        await exchangeTradeEmulator.transferFromAsync(
+            zrxTokenAddress, signedOrder.maker, signedOrder.feeRecipient, makerFeeAmount,
+            TradeSide.Maker, TransferType.Fee,
+        );
+    }
+    public async validateFillOrderThrowIfInvalidAsync(
+        exchangeTradeEmulator: ExchangeTransferSimulator, signedOrder: SignedOrder,
+        fillTakerTokenAmount: BigNumber, takerAddress: string,
+        zrxTokenAddress: string): Promise<BigNumber> {
+        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 unavailableTakerTokenAmount = await this.exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
+        this.validateRemainingFillAmountNotZeroOrThrow(
+            signedOrder.takerTokenAmount, unavailableTakerTokenAmount,
+        );
+        if (signedOrder.taker !== constants.NULL_ADDRESS && signedOrder.taker !== takerAddress) {
+            throw new Error(ExchangeContractErrs.TransactionSenderIsNotFillOrderTaker);
+        }
+        this.validateOrderNotExpiredOrThrow(signedOrder.expirationUnixTimestampSec);
+        const remainingTakerTokenAmount = signedOrder.takerTokenAmount.minus(unavailableTakerTokenAmount);
+        const filledTakerTokenAmount = remainingTakerTokenAmount.lessThan(fillTakerTokenAmount) ?
+                                       remainingTakerTokenAmount :
+                                       fillTakerTokenAmount;
+        await this.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+            exchangeTradeEmulator, signedOrder, filledTakerTokenAmount, takerAddress, zrxTokenAddress,
+        );
+
+        const wouldRoundingErrorOccur = await this.exchangeWrapper.isRoundingErrorAsync(
+            filledTakerTokenAmount, signedOrder.takerTokenAmount, signedOrder.makerTokenAmount,
+        );
+        if (wouldRoundingErrorOccur) {
+            throw new Error(ExchangeContractErrs.OrderFillRoundingError);
+        }
+        return filledTakerTokenAmount;
+    }
+    public async validateFillOrKillOrderThrowIfInvalidAsync(
+        exchangeTradeEmulator: ExchangeTransferSimulator, signedOrder: SignedOrder,
+        fillTakerTokenAmount: BigNumber, takerAddress: string, zrxTokenAddress: string): Promise<void> {
+        const filledTakerTokenAmount = await this.validateFillOrderThrowIfInvalidAsync(
+            exchangeTradeEmulator, signedOrder, fillTakerTokenAmount, takerAddress, zrxTokenAddress,
+        );
+        if (filledTakerTokenAmount !== fillTakerTokenAmount) {
+            throw new Error(ExchangeContractErrs.InsufficientRemainingFillAmount);
+        }
+    }
+    public async validateCancelOrderThrowIfInvalidAsync(order: Order,
+                                                        cancelTakerTokenAmount: BigNumber,
+                                                        unavailableTakerTokenAmount: BigNumber,
+    ): Promise<void> {
         if (cancelTakerTokenAmount.eq(0)) {
             throw new Error(ExchangeContractErrs.OrderCancelAmountZero);
         }
@@ -28,190 +107,60 @@ export class OrderValidationUtils {
             throw new Error(ExchangeContractErrs.OrderCancelExpired);
         }
     }
-    public static async validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
-        exchangeTradeEmulator: ExchangeTransferSimulator,
-        signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber,
-        senderAddress: string,
-        zrxTokenAddress: string,
-    ): Promise<void> {
-        const fillMakerTokenAmount = OrderValidationUtils._getPartialAmount(
+    public async validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+        exchangeTradeEmulator: ExchangeTransferSimulator, signedOrder: SignedOrder,
+        fillTakerTokenAmount: BigNumber, senderAddress: string, zrxTokenAddress: string): Promise<void> {
+        const fillMakerTokenAmount = this.getPartialAmount(
             fillTakerTokenAmount,
             signedOrder.takerTokenAmount,
             signedOrder.makerTokenAmount,
         );
         await exchangeTradeEmulator.transferFromAsync(
-            signedOrder.makerTokenAddress,
-            signedOrder.maker,
-            senderAddress,
-            fillMakerTokenAmount,
-            TradeSide.Maker,
-            TransferType.Trade,
+            signedOrder.makerTokenAddress, signedOrder.maker, senderAddress, fillMakerTokenAmount,
+            TradeSide.Maker, TransferType.Trade,
         );
         await exchangeTradeEmulator.transferFromAsync(
-            signedOrder.takerTokenAddress,
-            senderAddress,
-            signedOrder.maker,
-            fillTakerTokenAmount,
-            TradeSide.Taker,
-            TransferType.Trade,
+            signedOrder.takerTokenAddress, senderAddress, signedOrder.maker, fillTakerTokenAmount,
+            TradeSide.Taker, TransferType.Trade,
         );
-        const makerFeeAmount = OrderValidationUtils._getPartialAmount(
+        const makerFeeAmount = this.getPartialAmount(
             fillTakerTokenAmount,
             signedOrder.takerTokenAmount,
             signedOrder.makerFee,
         );
         await exchangeTradeEmulator.transferFromAsync(
-            zrxTokenAddress,
-            signedOrder.maker,
-            signedOrder.feeRecipient,
-            makerFeeAmount,
-            TradeSide.Maker,
+            zrxTokenAddress, signedOrder.maker, signedOrder.feeRecipient, makerFeeAmount, TradeSide.Maker,
             TransferType.Fee,
         );
-        const takerFeeAmount = OrderValidationUtils._getPartialAmount(
+        const takerFeeAmount = this.getPartialAmount(
             fillTakerTokenAmount,
             signedOrder.takerTokenAmount,
             signedOrder.takerFee,
         );
         await exchangeTradeEmulator.transferFromAsync(
-            zrxTokenAddress,
-            senderAddress,
-            signedOrder.feeRecipient,
-            takerFeeAmount,
-            TradeSide.Taker,
+            zrxTokenAddress, senderAddress, signedOrder.feeRecipient, takerFeeAmount, TradeSide.Taker,
             TransferType.Fee,
         );
     }
-    private static _validateRemainingFillAmountNotZeroOrThrow(
-        takerTokenAmount: BigNumber,
-        unavailableTakerTokenAmount: BigNumber,
+    private validateRemainingFillAmountNotZeroOrThrow(
+        takerTokenAmount: BigNumber, unavailableTakerTokenAmount: BigNumber,
     ) {
         if (takerTokenAmount.eq(unavailableTakerTokenAmount)) {
             throw new Error(ExchangeContractErrs.OrderRemainingFillAmountZero);
         }
     }
-    private static _validateOrderNotExpiredOrThrow(expirationUnixTimestampSec: BigNumber) {
+    private validateOrderNotExpiredOrThrow(expirationUnixTimestampSec: BigNumber) {
         const currentUnixTimestampSec = utils.getCurrentUnixTimestampSec();
         if (expirationUnixTimestampSec.lessThan(currentUnixTimestampSec)) {
             throw new Error(ExchangeContractErrs.OrderFillExpired);
         }
     }
-    private static _getPartialAmount(numerator: BigNumber, denominator: BigNumber, target: BigNumber): BigNumber {
+    private getPartialAmount(numerator: BigNumber, denominator: BigNumber,
+                             target: BigNumber): BigNumber {
         const fillMakerTokenAmount = numerator
-            .mul(target)
-            .div(denominator)
-            .round(0);
+                                     .mul(target)
+                                     .div(denominator)
+                                     .round(0);
         return fillMakerTokenAmount;
     }
-    constructor(exchangeWrapper: ExchangeWrapper) {
-        this._exchangeWrapper = exchangeWrapper;
-    }
-    public async validateOrderFillableOrThrowAsync(
-        exchangeTradeEmulator: ExchangeTransferSimulator,
-        signedOrder: SignedOrder,
-        zrxTokenAddress: string,
-        expectedFillTakerTokenAmount?: BigNumber,
-    ): Promise<void> {
-        const orderHash = utils.getOrderHashHex(signedOrder);
-        const unavailableTakerTokenAmount = await this._exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
-        OrderValidationUtils._validateRemainingFillAmountNotZeroOrThrow(
-            signedOrder.takerTokenAmount,
-            unavailableTakerTokenAmount,
-        );
-        OrderValidationUtils._validateOrderNotExpiredOrThrow(signedOrder.expirationUnixTimestampSec);
-        let fillTakerTokenAmount = signedOrder.takerTokenAmount.minus(unavailableTakerTokenAmount);
-        if (!_.isUndefined(expectedFillTakerTokenAmount)) {
-            fillTakerTokenAmount = expectedFillTakerTokenAmount;
-        }
-        const fillMakerTokenAmount = OrderValidationUtils._getPartialAmount(
-            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(
-        exchangeTradeEmulator: ExchangeTransferSimulator,
-        signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber,
-        takerAddress: string,
-        zrxTokenAddress: string,
-    ): Promise<BigNumber> {
-        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 unavailableTakerTokenAmount = await this._exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
-        OrderValidationUtils._validateRemainingFillAmountNotZeroOrThrow(
-            signedOrder.takerTokenAmount,
-            unavailableTakerTokenAmount,
-        );
-        if (signedOrder.taker !== constants.NULL_ADDRESS && signedOrder.taker !== takerAddress) {
-            throw new Error(ExchangeContractErrs.TransactionSenderIsNotFillOrderTaker);
-        }
-        OrderValidationUtils._validateOrderNotExpiredOrThrow(signedOrder.expirationUnixTimestampSec);
-        const remainingTakerTokenAmount = signedOrder.takerTokenAmount.minus(unavailableTakerTokenAmount);
-        const filledTakerTokenAmount = remainingTakerTokenAmount.lessThan(fillTakerTokenAmount)
-            ? remainingTakerTokenAmount
-            : fillTakerTokenAmount;
-        await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
-            exchangeTradeEmulator,
-            signedOrder,
-            filledTakerTokenAmount,
-            takerAddress,
-            zrxTokenAddress,
-        );
-
-        const wouldRoundingErrorOccur = await this._exchangeWrapper.isRoundingErrorAsync(
-            filledTakerTokenAmount,
-            signedOrder.takerTokenAmount,
-            signedOrder.makerTokenAmount,
-        );
-        if (wouldRoundingErrorOccur) {
-            throw new Error(ExchangeContractErrs.OrderFillRoundingError);
-        }
-        return filledTakerTokenAmount;
-    }
-    public async validateFillOrKillOrderThrowIfInvalidAsync(
-        exchangeTradeEmulator: ExchangeTransferSimulator,
-        signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber,
-        takerAddress: string,
-        zrxTokenAddress: string,
-    ): Promise<void> {
-        const filledTakerTokenAmount = await this.validateFillOrderThrowIfInvalidAsync(
-            exchangeTradeEmulator,
-            signedOrder,
-            fillTakerTokenAmount,
-            takerAddress,
-            zrxTokenAddress,
-        );
-        if (filledTakerTokenAmount !== fillTakerTokenAmount) {
-            throw new Error(ExchangeContractErrs.InsufficientRemainingFillAmount);
-        }
-    }
 }

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

@@ -1,5 +1,5 @@
-import { ECSignature } from '@0xproject/types';
 import * as ethUtil from 'ethereumjs-util';
+import {ECSignature} from '../types';
 
 export const signatureUtils = {
     isValidSignature(data: string, signature: ECSignature, signerAddress: string): boolean {
@@ -10,8 +10,7 @@ export const signatureUtils = {
                 msgHashBuff,
                 signature.v,
                 ethUtil.toBuffer(signature.r),
-                ethUtil.toBuffer(signature.s),
-            );
+                ethUtil.toBuffer(signature.s));
             const retrievedAddress = ethUtil.bufferToHex(ethUtil.pubToAddress(pubKey));
             return retrievedAddress === signerAddress;
         } catch (err) {
@@ -34,7 +33,7 @@ export const signatureUtils = {
         return ecSignature;
     },
     parseSignatureHexAsRSV(signatureHex: string): ECSignature {
-        const { v, r, s } = ethUtil.fromRpcSig(signatureHex);
+        const {v, r, s} = ethUtil.fromRpcSig(signatureHex);
         const ecSignature: ECSignature = {
             v,
             r: ethUtil.bufferToHex(r),

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

@@ -1,9 +1,9 @@
-import { Order, SignedOrder, SolidityTypes } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
-import BN = require('bn.js');
+import * as _ from 'lodash';
 import * as ethABI from 'ethereumjs-abi';
 import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
+import {Order, SignedOrder, SolidityTypes} from '../types';
+import BigNumber from 'bignumber.js';
+import BN = require('bn.js');
 
 export const utils = {
     /**
@@ -15,38 +15,33 @@ export const utils = {
     bigNumberToBN(value: BigNumber) {
         return new BN(value.toString(), 10);
     },
+    consoleLog(message: string): void {
+        // tslint:disable-next-line: no-console
+        console.log(message);
+    },
+    isParityNode(nodeVersion: string): boolean {
+        return _.includes(nodeVersion, 'Parity');
+    },
+    isTestRpc(nodeVersion: string): boolean {
+        return _.includes(nodeVersion, 'TestRPC');
+    },
     spawnSwitchErr(name: string, value: any): Error {
         return new Error(`Unexpected switch value: ${value} encountered for ${name}`);
     },
-    getOrderHashHex(order: Order | SignedOrder): string {
+    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 },
+            {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);

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

@@ -0,0 +1,202 @@
+import * as _ from 'lodash';
+import * as Web3 from 'web3';
+import BigNumber from 'bignumber.js';
+import promisify = require('es6-promisify');
+import {ZeroExError, Artifact, TransactionReceipt} from './types';
+import {Contract} from './contract';
+
+interface RawLogEntry {
+    logIndex: string|null;
+    transactionIndex: string|null;
+    transactionHash: string;
+    blockHash: string|null;
+    blockNumber: string|null;
+    address: string;
+    data: string;
+    topics: string[];
+}
+
+export class Web3Wrapper {
+    private web3: Web3;
+    private defaults: Partial<Web3.TxData>;
+    private networkIdIfExists?: number;
+    private jsonRpcRequestId: number;
+    constructor(provider: Web3.Provider, defaults?: Partial<Web3.TxData>) {
+        if (_.isUndefined((provider as any).sendAsync)) {
+            // Web3@1.0 provider doesn't support synchronous http requests,
+            // so it only has an async `send` method, instead of a `send` and `sendAsync` in web3@0.x.x`
+            // We re-assign the send method so that Web3@1.0 providers work with 0x.js
+            (provider as any).sendAsync = (provider as any).send;
+        }
+        this.web3 = new Web3();
+        this.web3.setProvider(provider);
+        this.defaults = defaults || {};
+        this.jsonRpcRequestId = 0;
+    }
+    public setProvider(provider: Web3.Provider) {
+        delete this.networkIdIfExists;
+        this.web3.setProvider(provider);
+    }
+    public isAddress(address: string): boolean {
+        return this.web3.isAddress(address);
+    }
+    public async isSenderAddressAvailableAsync(senderAddress: string): Promise<boolean> {
+        const addresses = await this.getAvailableAddressesAsync();
+        return _.includes(addresses, senderAddress);
+    }
+    public async getNodeVersionAsync(): Promise<string> {
+        const nodeVersion = await promisify(this.web3.version.getNode)();
+        return nodeVersion;
+    }
+    public async getTransactionReceiptAsync(txHash: string): Promise<TransactionReceipt> {
+        const transactionReceipt = await promisify(this.web3.eth.getTransactionReceipt)(txHash);
+        if (!_.isNull(transactionReceipt)) {
+            transactionReceipt.status = this.normalizeTxReceiptStatus(transactionReceipt.status);
+        }
+        return transactionReceipt;
+    }
+    public getCurrentProvider(): Web3.Provider {
+        return this.web3.currentProvider;
+    }
+    public async getNetworkIdIfExistsAsync(): Promise<number|undefined> {
+        if (!_.isUndefined(this.networkIdIfExists)) {
+          return this.networkIdIfExists;
+        }
+
+        try {
+            const networkId = await this.getNetworkAsync();
+            this.networkIdIfExists = Number(networkId);
+            return this.networkIdIfExists;
+        } catch (err) {
+            return undefined;
+        }
+    }
+    public async getContractInstanceFromArtifactAsync<A extends Web3.ContractInstance>(artifact: Artifact,
+                                                                                       address?: string): Promise<A> {
+        let contractAddress: string;
+        if (_.isUndefined(address)) {
+            const networkIdIfExists = await this.getNetworkIdIfExistsAsync();
+            if (_.isUndefined(networkIdIfExists)) {
+                throw new Error(ZeroExError.NoNetworkId);
+            }
+            if (_.isUndefined(artifact.networks[networkIdIfExists])) {
+                throw new Error(ZeroExError.ContractNotDeployedOnNetwork);
+            }
+            contractAddress = artifact.networks[networkIdIfExists].address.toLowerCase();
+        } else {
+            contractAddress = address;
+        }
+        const doesContractExist = await this.doesContractExistAtAddressAsync(contractAddress);
+        if (!doesContractExist) {
+            throw new Error(ZeroExError.ContractDoesNotExist);
+        }
+        const contractInstance = this.getContractInstance<A>(
+            artifact.abi, contractAddress,
+        );
+        return contractInstance;
+    }
+    public toWei(ethAmount: BigNumber): BigNumber {
+        const balanceWei = this.web3.toWei(ethAmount, 'ether');
+        return balanceWei;
+    }
+    public async getBalanceInWeiAsync(owner: string): Promise<BigNumber> {
+        let balanceInWei = await promisify(this.web3.eth.getBalance)(owner);
+        balanceInWei = new BigNumber(balanceInWei);
+        return balanceInWei;
+    }
+    public async doesContractExistAtAddressAsync(address: string): Promise<boolean> {
+        const code = await promisify(this.web3.eth.getCode)(address);
+        // Regex matches 0x0, 0x00, 0x in order to accommodate poorly implemented clients
+        const codeIsEmpty = /^0x0{0,40}$/i.test(code);
+        return !codeIsEmpty;
+    }
+    public async signTransactionAsync(address: string, message: string): Promise<string> {
+        const signData = await promisify(this.web3.eth.sign)(address, message);
+        return signData;
+    }
+    public async getBlockNumberAsync(): Promise<number> {
+        const blockNumber = await promisify(this.web3.eth.getBlockNumber)();
+        return blockNumber;
+    }
+    public async getBlockAsync(blockParam: string|Web3.BlockParam): Promise<Web3.BlockWithoutTransactionData> {
+        const block = await promisify(this.web3.eth.getBlock)(blockParam);
+        return block;
+    }
+    public async getBlockTimestampAsync(blockParam: string|Web3.BlockParam): Promise<number> {
+        const {timestamp} = await this.getBlockAsync(blockParam);
+        return timestamp;
+    }
+    public async getAvailableAddressesAsync(): Promise<string[]> {
+        const addresses: string[] = await promisify(this.web3.eth.getAccounts)();
+        return addresses;
+    }
+    public async getLogsAsync(filter: Web3.FilterObject): Promise<Web3.LogEntry[]> {
+        let fromBlock = filter.fromBlock;
+        if (_.isNumber(fromBlock)) {
+            fromBlock = this.web3.toHex(fromBlock);
+        }
+        let toBlock = filter.toBlock;
+        if (_.isNumber(toBlock)) {
+            toBlock = this.web3.toHex(toBlock);
+        }
+        const serializedFilter = {
+            ...filter,
+            fromBlock,
+            toBlock,
+        };
+        const payload = {
+            jsonrpc: '2.0',
+            id: this.jsonRpcRequestId++,
+            method: 'eth_getLogs',
+            params: [serializedFilter],
+        };
+        const rawLogs = await this.sendRawPayloadAsync<RawLogEntry[]>(payload);
+        const formattedLogs = _.map(rawLogs, this.formatLog.bind(this));
+        return formattedLogs;
+    }
+    private getContractInstance<A extends Web3.ContractInstance>(abi: Web3.ContractAbi, address: string): A {
+        const web3ContractInstance = this.web3.eth.contract(abi).at(address);
+        const contractInstance = new Contract(web3ContractInstance, this.defaults) as any as A;
+        return contractInstance;
+    }
+    private async getNetworkAsync(): Promise<number> {
+        const networkId = await promisify(this.web3.version.getNetwork)();
+        return networkId;
+    }
+    private async sendRawPayloadAsync<A>(payload: Web3.JSONRPCRequestPayload): Promise<A> {
+        const sendAsync = this.web3.currentProvider.sendAsync.bind(this.web3.currentProvider);
+        const response = await promisify(sendAsync)(payload);
+        const result = response.result;
+        return result;
+    }
+    private normalizeTxReceiptStatus(status: undefined|null|string|0|1): null|0|1 {
+        // Transaction status might have four values
+        // undefined - Testrpc and other old clients
+        // null - New clients on old transactions
+        // number - Parity
+        // hex - Geth
+        if (_.isString(status)) {
+            return this.web3.toDecimal(status) as 0|1;
+        } else if (_.isUndefined(status)) {
+            return null;
+        } else {
+            return status;
+        }
+    }
+    private formatLog(rawLog: RawLogEntry): Web3.LogEntry {
+        const formattedLog = {
+            ...rawLog,
+            logIndex: this.hexToDecimal(rawLog.logIndex),
+            blockNumber: this.hexToDecimal(rawLog.blockNumber),
+            transactionIndex: this.hexToDecimal(rawLog.transactionIndex),
+        };
+        return formattedLog;
+    }
+    private hexToDecimal(hex: string|null): number|null {
+        if (_.isNull(hex)) {
+            return null;
+        }
+        const decimal = this.web3.toDecimal(hex);
+        return decimal;
+    }
+}

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

@@ -1,28 +1,22 @@
-import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
-import { BigNumber } from '@0xproject/utils';
-import * as chai from 'chai';
 import * as _ from 'lodash';
+import * as chai from 'chai';
+import {chaiSetup} from './utils/chai_setup';
 import 'mocha';
+import BigNumber from 'bignumber.js';
 import * as Sinon from 'sinon';
+import {ZeroEx, Order, ZeroExError, LogWithDecodedArgs, ApprovalContractEventArgs, TokenEvents} from '../src';
+import {constants} from './utils/constants';
+import {TokenUtils} from './utils/token_utils';
+import {web3Factory} from './utils/web3_factory';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
 
-import { ApprovalContractEventArgs, LogWithDecodedArgs, Order, TokenEvents, ZeroEx } from '../src';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
-import { TokenUtils } from './utils/token_utils';
-import { web3, web3Wrapper } from './utils/web3_wrapper';
-
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+const blockchainLifecycle = new BlockchainLifecycle();
 chaiSetup.configure();
 const expect = chai.expect;
 
-const SHOULD_ADD_PERSONAL_MESSAGE_PREFIX = false;
-
 describe('ZeroEx library', () => {
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
-    const zeroEx = new ZeroEx(web3.currentProvider, config);
+    const web3 = web3Factory.create();
+    const zeroEx = new ZeroEx(web3.currentProvider);
     describe('#setProvider', () => {
         it('overrides provider in nested web3s and invalidates contractInstances', async () => {
             // Instantiate the contract instances with the current provider
@@ -34,19 +28,19 @@ describe('ZeroEx library', () => {
             const newProvider = web3Factory.getRpcProvider();
             // Add property to newProvider so that we can differentiate it from old provider
             (newProvider as any).zeroExTestId = 1;
-            zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
+            await zeroEx.setProviderAsync(newProvider);
 
             // Check that contractInstances with old provider are removed after provider update
             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');
-            const exchangeWeb3WrapperProvider = (zeroEx.exchange as any)._web3Wrapper.getProvider();
-            expect(exchangeWeb3WrapperProvider.zeroExTestId).to.be.a('number');
-            const tokenRegistryWeb3WrapperProvider = (zeroEx.tokenRegistry as any)._web3Wrapper.getProvider();
-            expect(tokenRegistryWeb3WrapperProvider.zeroExTestId).to.be.a('number');
+            const nestedWeb3WrapperProvider = (zeroEx as any)._web3Wrapper.getCurrentProvider();
+            expect((nestedWeb3WrapperProvider as any).zeroExTestId).to.be.a('number');
+            const exchangeWeb3WrapperProvider = (zeroEx.exchange as any)._web3Wrapper.getCurrentProvider();
+            expect((exchangeWeb3WrapperProvider as any).zeroExTestId).to.be.a('number');
+            const tokenRegistryWeb3WrapperProvider = (zeroEx.tokenRegistry as any)._web3Wrapper.getCurrentProvider();
+            expect((tokenRegistryWeb3WrapperProvider as any).zeroExTestId).to.be.a('number');
         });
     });
     describe('#isValidSignature', () => {
@@ -59,25 +53,22 @@ describe('ZeroEx library', () => {
             s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
         };
         const address = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
-        it("should return false if the data doesn't pertain to the signature & address", async () => {
+        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 () => {
+        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,
-                    signature,
-                    validUnrelatedAddress,
-                ),
+                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(dataHex, signature,
+                                                                                validUnrelatedAddress),
             ).to.become(false);
         });
-        it("should return false if the signature doesn't pertain to the dataHex & address", async () => {
-            const wrongSignature = _.assign({}, signature, { v: 28 });
+        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),
@@ -86,9 +77,9 @@ describe('ZeroEx library', () => {
         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);
+            const isValidSignatureOnContract = await (zeroEx.exchange as any)
+                ._isValidSignatureUsingContractCallAsync(dataHex, signature, address);
+            return expect(isValidSignatureOnContract).to.be.true();
         });
     });
     describe('#generateSalt', () => {
@@ -118,13 +109,6 @@ describe('ZeroEx library', () => {
         });
     });
     describe('#toUnitAmount', () => {
-        it('should throw if invalid baseUnit amount supplied as argument', () => {
-            const invalidBaseUnitAmount = new BigNumber(1000000000.4);
-            const decimals = 6;
-            expect(() => ZeroEx.toUnitAmount(invalidBaseUnitAmount, decimals)).to.throw(
-                'amount should be in baseUnits (no decimals), found value: 1000000000.4',
-            );
-        });
         it('Should return the expected unit amount for the decimals passed in', () => {
             const baseUnitAmount = new BigNumber(1000000000);
             const decimals = 6;
@@ -141,13 +125,6 @@ describe('ZeroEx library', () => {
             const expectedUnitAmount = new BigNumber(1000000000);
             expect(baseUnitAmount).to.be.bignumber.equal(expectedUnitAmount);
         });
-        it('should throw if unitAmount has more decimals then specified as the max decimal precision', () => {
-            const unitAmount = new BigNumber(0.823091);
-            const decimals = 5;
-            expect(() => ZeroEx.toBaseUnitAmount(unitAmount, decimals)).to.throw(
-                'Invalid unit amount: 0.823091 - Too many decimal places',
-            );
-        });
     });
     describe('#getOrderHashHex', () => {
         const expectedOrderHash = '0x39da987067a3c9e5f1617694f1301326ba8c8b0498ebef5df4863bed394e3c83';
@@ -170,15 +147,6 @@ describe('ZeroEx library', () => {
             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[] = [];
@@ -199,53 +167,43 @@ describe('ZeroEx library', () => {
                 r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
                 s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
             };
-            const ecSignature = await zeroEx.signOrderHashAsync(
-                orderHash,
-                makerAddress,
-                SHOULD_ADD_PERSONAL_MESSAGE_PREFIX,
-            );
+            const ecSignature = await zeroEx.signOrderHashAsync(orderHash, makerAddress);
             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';
+            // tslint:disable-next-line: max-line-length
+            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 as any)._web3Wrapper, 'signTransactionAsync')
+                    .returns(Promise.resolve(signature)),
                 Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
             ];
 
-            const ecSignature = await zeroEx.signOrderHashAsync(
-                orderHash,
-                makerAddress,
-                SHOULD_ADD_PERSONAL_MESSAGE_PREFIX,
-            );
+            const ecSignature = await zeroEx.signOrderHashAsync(orderHash, makerAddress);
             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';
+            // tslint:disable-next-line: max-line-length
+            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 as any)._web3Wrapper, 'signTransactionAsync')
+                    .returns(Promise.resolve(signature)),
                 Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
             ];
 
-            const ecSignature = await zeroEx.signOrderHashAsync(
-                orderHash,
-                makerAddress,
-                SHOULD_ADD_PERSONAL_MESSAGE_PREFIX,
-            );
+            const ecSignature = await zeroEx.signOrderHashAsync(orderHash, makerAddress);
             expect(ecSignature).to.deep.equal(expectedECSignature);
         });
     });
@@ -262,7 +220,7 @@ describe('ZeroEx library', () => {
             const tokens = await zeroEx.tokenRegistry.getTokensAsync();
             const tokenUtils = new TokenUtils(tokens);
             const zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
-            const proxyAddress = zeroEx.proxy.getContractAddress();
+            const proxyAddress = await zeroEx.proxy.getContractAddressAsync();
             const txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(zrxTokenAddress, coinbase);
             const txReceiptWithDecodedLogs = await zeroEx.awaitTransactionMinedAsync(txHash);
             const log = txReceiptWithDecodedLogs.logs[0] as LogWithDecodedArgs<ApprovalContractEventArgs>;
@@ -274,22 +232,28 @@ describe('ZeroEx library', () => {
     });
     describe('#config', () => {
         it('allows to specify exchange contract address', async () => {
-            const zeroExConfig = {
+            const config = {
                 exchangeContractAddress: ZeroEx.NULL_ADDRESS,
-                networkId: constants.TESTRPC_NETWORK_ID,
             };
-            const zeroExWithWrongExchangeAddress = new ZeroEx(web3.currentProvider, zeroExConfig);
-            expect(zeroExWithWrongExchangeAddress.exchange.getContractAddress()).to.be.equal(ZeroEx.NULL_ADDRESS);
+            const zeroExWithWrongExchangeAddress = new ZeroEx(web3.currentProvider, config);
+            return expect(zeroExWithWrongExchangeAddress.exchange.getContractAddressAsync())
+                .to.be.rejectedWith(ZeroExError.ContractDoesNotExist);
+        });
+        it('allows to specify ether token contract address', async () => {
+            const config = {
+                etherTokenContractAddress: ZeroEx.NULL_ADDRESS,
+            };
+            const zeroExWithWrongEtherTokenAddress = new ZeroEx(web3.currentProvider, config);
+            return expect(zeroExWithWrongEtherTokenAddress.etherToken.getContractAddressAsync())
+                .to.be.rejectedWith(ZeroExError.ContractDoesNotExist);
         });
         it('allows to specify token registry token contract address', async () => {
-            const zeroExConfig = {
+            const config = {
                 tokenRegistryContractAddress: ZeroEx.NULL_ADDRESS,
-                networkId: constants.TESTRPC_NETWORK_ID,
             };
-            const zeroExWithWrongTokenRegistryAddress = new ZeroEx(web3.currentProvider, zeroExConfig);
-            expect(zeroExWithWrongTokenRegistryAddress.tokenRegistry.getContractAddress()).to.be.equal(
-                ZeroEx.NULL_ADDRESS,
-            );
+            const zeroExWithWrongTokenRegistryAddress = new ZeroEx(web3.currentProvider, config);
+            return expect(zeroExWithWrongTokenRegistryAddress.tokenRegistry.getContractAddressAsync())
+                .to.be.rejectedWith(ZeroExError.ContractDoesNotExist);
         });
     });
 });

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

@@ -1,12 +1,12 @@
 import * as fs from 'fs';
+import * as chai from 'chai';
+import {chaiSetup} from './utils/chai_setup';
 import HDWalletProvider = require('truffle-hdwallet-provider');
-
-import { ZeroEx } from '../src';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
+import {ZeroEx} from '../src';
+import {constants} from './utils/constants';
 
 chaiSetup.configure();
+const expect = chai.expect;
 
 // Those tests are slower cause they're talking to a remote node
 const TIMEOUT = 10000;
@@ -18,18 +18,15 @@ describe('Artifacts', () => {
         const packageJSON = JSON.parse(packageJSONContent);
         const mnemonic = packageJSON.config.mnemonic;
         const web3Provider = new HDWalletProvider(mnemonic, kovanRpcUrl);
-        const config = {
-            networkId: constants.KOVAN_NETWORK_ID,
-        };
-        const zeroEx = new ZeroEx(web3Provider, config);
+        const zeroEx = new ZeroEx(web3Provider);
         it('token registry contract is deployed', async () => {
             await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
         }).timeout(TIMEOUT);
         it('proxy contract is deployed', async () => {
-            await (zeroEx.proxy as any)._getTokenTransferProxyContractAsync();
+            await (zeroEx.token as any)._getTokenTransferProxyAddressAsync();
         }).timeout(TIMEOUT);
         it('exchange contract is deployed', async () => {
-            await (zeroEx.exchange as any)._getExchangeContractAsync();
+            await zeroEx.exchange.getContractAddressAsync();
         }).timeout(TIMEOUT);
     });
     describe('contracts are deployed on ropsten', () => {
@@ -38,18 +35,15 @@ describe('Artifacts', () => {
         const packageJSON = JSON.parse(packageJSONContent);
         const mnemonic = packageJSON.config.mnemonic;
         const web3Provider = new HDWalletProvider(mnemonic, ropstenRpcUrl);
-        const config = {
-            networkId: constants.ROPSTEN_NETWORK_ID,
-        };
-        const zeroEx = new ZeroEx(web3Provider, config);
+        const zeroEx = new ZeroEx(web3Provider);
         it('token registry contract is deployed', async () => {
             await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
         }).timeout(TIMEOUT);
         it('proxy contract is deployed', async () => {
-            await (zeroEx.proxy as any)._getTokenTransferProxyContractAsync();
+            await (zeroEx.token as any)._getTokenTransferProxyAddressAsync();
         }).timeout(TIMEOUT);
         it('exchange contract is deployed', async () => {
-            await (zeroEx.exchange as any)._getExchangeContractAsync();
+            await zeroEx.exchange.getContractAddressAsync();
         }).timeout(TIMEOUT);
     });
 });

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

@@ -1,43 +1,34 @@
-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 {ZeroEx} from '../src';
+import {assert} from '../src/utils/assert';
+import {web3Factory} from './utils/web3_factory';
 
 const expect = chai.expect;
 
 describe('Assertion library', () => {
     const web3 = web3Factory.create();
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
-    const zeroEx = new ZeroEx(web3.currentProvider, config);
+    const zeroEx = new ZeroEx(web3.currentProvider);
     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}`);
+            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`,
-            );
+            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 () => {
+        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);
+            return expect(assert.isSenderAddressAsync(varName, availableAddress, (zeroEx as any)._web3Wrapper))
+                .to.become(undefined);
         });
     });
 });

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

@@ -1,67 +1,42 @@
-import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
-import { BigNumber } from '@0xproject/utils';
-import * as chai from 'chai';
 import 'mocha';
+import * as chai from 'chai';
+import {chaiSetup} from './utils/chai_setup';
 import * as Web3 from 'web3';
-
-import {
-    ApprovalContractEventArgs,
-    BlockParamLiteral,
-    BlockRange,
-    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 { web3, web3Wrapper } from './utils/web3_wrapper';
+import BigNumber from 'bignumber.js';
+import {web3Factory} from './utils/web3_factory';
+import {ZeroEx, ZeroExError} from '../src';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+const blockchainLifecycle = new BlockchainLifecycle();
 
 // Since the address depositing/withdrawing ETH/WETH also needs to pay gas costs for the transaction,
 // a small amount of ETH will be used to pay this gas cost. We therefore check that the difference between
 // the expected balance and actual balance (given the amount of ETH deposited), only deviates by the amount
 // required to pay gas costs.
-const MAX_REASONABLE_GAS_COST_IN_WEI = 62517;
+const MAX_REASONABLE_GAS_COST_IN_WEI = 62237;
 
 describe('EtherTokenWrapper', () => {
+    let web3: Web3;
     let zeroEx: ZeroEx;
-    let tokens: Token[];
     let userAddresses: string[];
     let addressWithETH: string;
     let wethContractAddress: string;
     let depositWeiAmount: BigNumber;
     let decimalPlaces: number;
-    let addressWithoutFunds: string;
     const gasPrice = new BigNumber(1);
     const zeroExConfig = {
         gasPrice,
-        networkId: constants.TESTRPC_NETWORK_ID,
     };
-    const transferAmount = new BigNumber(42);
-    const allowanceAmount = new BigNumber(42);
-    const depositAmount = new BigNumber(42);
-    const withdrawalAmount = new BigNumber(42);
     before(async () => {
+        web3 = web3Factory.create();
         zeroEx = new ZeroEx(web3.currentProvider, zeroExConfig);
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         addressWithETH = userAddresses[0];
-        wethContractAddress = zeroEx.etherToken.getContractAddressIfExists() as string;
+        wethContractAddress = await zeroEx.etherToken.getContractAddressAsync();
         depositWeiAmount = (zeroEx as any)._web3Wrapper.toWei(new BigNumber(5));
         decimalPlaces = 7;
-        addressWithoutFunds = userAddresses[1];
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
@@ -69,21 +44,6 @@ describe('EtherTokenWrapper', () => {
     afterEach(async () => {
         await blockchainLifecycle.revertAsync();
     });
-    describe('#getContractAddressIfExists', async () => {
-        it('should return contract address if connected to a known network', () => {
-            const contractAddressIfExists = zeroEx.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(web3.currentProvider, {
-                        networkId: UNKNOWN_NETWORK_NETWORK_ID,
-                    } as any),
-            ).to.throw();
-        });
-    });
     describe('#depositAsync', () => {
         it('should successfully deposit ETH and issue Wrapped ETH tokens', async () => {
             const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
@@ -91,7 +51,7 @@ describe('EtherTokenWrapper', () => {
             expect(preETHBalance).to.be.bignumber.gt(0);
             expect(preWETHBalance).to.be.bignumber.equal(0);
 
-            const txHash = await zeroEx.etherToken.depositAsync(wethContractAddress, depositWeiAmount, addressWithETH);
+            const txHash = await zeroEx.etherToken.depositAsync(depositWeiAmount, addressWithETH);
             await zeroEx.awaitTransactionMinedAsync(txHash);
 
             const postETHBalanceInWei = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
@@ -109,7 +69,7 @@ describe('EtherTokenWrapper', () => {
             const overETHBalanceinWei = preETHBalance.add(extraETHBalance);
 
             return expect(
-                zeroEx.etherToken.depositAsync(wethContractAddress, overETHBalanceinWei, addressWithETH),
+                zeroEx.etherToken.depositAsync(overETHBalanceinWei, addressWithETH),
             ).to.be.rejectedWith(ZeroExError.InsufficientEthBalanceForDeposit);
         });
     });
@@ -117,7 +77,7 @@ describe('EtherTokenWrapper', () => {
         it('should successfully withdraw ETH in return for Wrapped ETH tokens', async () => {
             const ETHBalanceInWei = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
 
-            await zeroEx.etherToken.depositAsync(wethContractAddress, depositWeiAmount, addressWithETH);
+            await zeroEx.etherToken.depositAsync(depositWeiAmount, addressWithETH);
 
             const expectedPreETHBalance = ETHBalanceInWei.minus(depositWeiAmount);
             const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
@@ -126,7 +86,7 @@ describe('EtherTokenWrapper', () => {
             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);
+            const txHash = await zeroEx.etherToken.withdrawAsync(depositWeiAmount, addressWithETH);
             await zeroEx.awaitTransactionMinedAsync(txHash);
 
             const postETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
@@ -137,251 +97,15 @@ describe('EtherTokenWrapper', () => {
             gasCost = expectedETHBalance.minus(postETHBalance);
             expect(gasCost).to.be.bignumber.lte(MAX_REASONABLE_GAS_COST_IN_WEI);
         });
-        it('should throw if user has insufficient WETH balance for withdrawal', async () => {
+        it('should throw if user has insufficient WETH balance for withdrawl', async () => {
             const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
             expect(preWETHBalance).to.be.bignumber.equal(0);
 
             const overWETHBalance = preWETHBalance.add(999999999);
 
             return expect(
-                zeroEx.etherToken.withdrawAsync(wethContractAddress, overWETHBalance, addressWithETH),
+                zeroEx.etherToken.withdrawAsync(overWETHBalance, addressWithETH),
             ).to.be.rejectedWith(ZeroExError.InsufficientWEthBalanceForWithdrawal);
         });
     });
-    describe('#subscribe', () => {
-        const indexFilterValues = {};
-        let etherTokenAddress: string;
-        before(() => {
-            const tokenUtils = new TokenUtils(tokens);
-            const etherToken = tokenUtils.getWethTokenOrThrow();
-            etherTokenAddress = etherToken.address;
-        });
-        afterEach(() => {
-            zeroEx.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,
-        // we do need both. A hack is to make the top-level async fn w/ a done callback and then
-        // wrap the rest of the test in an async block
-        // 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)(
-                    (logEvent: DecodedLogEvent<TransferContractEventArgs>) => {
-                        expect(logEvent).to.not.be.undefined();
-                        expect(logEvent.isRemoved).to.be.false();
-                        expect(logEvent.log.logIndex).to.be.equal(0);
-                        expect(logEvent.log.transactionIndex).to.be.equal(0);
-                        expect(logEvent.log.blockNumber).to.be.a('number');
-                        const args = logEvent.log.args;
-                        expect(args._from).to.be.equal(addressWithETH);
-                        expect(args._to).to.be.equal(addressWithoutFunds);
-                        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(
-                    etherTokenAddress,
-                    addressWithETH,
-                    addressWithoutFunds,
-                    transferAmount,
-                );
-            })().catch(done);
-        });
-        it('Should receive the Approval event when allowance is being set', (done: DoneCallback) => {
-            (async () => {
-                const callback = reportNodeCallbackErrors(done)(
-                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-                        expect(logEvent).to.not.be.undefined();
-                        expect(logEvent.isRemoved).to.be.false();
-                        const args = logEvent.log.args;
-                        expect(args._owner).to.be.equal(addressWithETH);
-                        expect(args._spender).to.be.equal(addressWithoutFunds);
-                        expect(args._value).to.be.bignumber.equal(allowanceAmount);
-                    },
-                );
-                zeroEx.etherToken.subscribe(etherTokenAddress, EtherTokenEvents.Approval, indexFilterValues, callback);
-                await zeroEx.token.setAllowanceAsync(
-                    etherTokenAddress,
-                    addressWithETH,
-                    addressWithoutFunds,
-                    allowanceAmount,
-                );
-            })().catch(done);
-        });
-        it('Should receive the Deposit event when ether is being deposited', (done: DoneCallback) => {
-            (async () => {
-                const callback = reportNodeCallbackErrors(done)(
-                    (logEvent: DecodedLogEvent<DepositContractEventArgs>) => {
-                        expect(logEvent).to.not.be.undefined();
-                        expect(logEvent.isRemoved).to.be.false();
-                        const args = logEvent.log.args;
-                        expect(args._owner).to.be.equal(addressWithETH);
-                        expect(args._value).to.be.bignumber.equal(depositAmount);
-                    },
-                );
-                zeroEx.etherToken.subscribe(etherTokenAddress, EtherTokenEvents.Deposit, indexFilterValues, callback);
-                await zeroEx.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)(
-                    (logEvent: DecodedLogEvent<WithdrawalContractEventArgs>) => {
-                        expect(logEvent).to.not.be.undefined();
-                        expect(logEvent.isRemoved).to.be.false();
-                        const args = logEvent.log.args;
-                        expect(args._owner).to.be.equal(addressWithETH);
-                        expect(args._value).to.be.bignumber.equal(depositAmount);
-                    },
-                );
-                await zeroEx.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
-                zeroEx.etherToken.subscribe(
-                    etherTokenAddress,
-                    EtherTokenEvents.Withdrawal,
-                    indexFilterValues,
-                    callback,
-                );
-                await zeroEx.etherToken.withdrawAsync(etherTokenAddress, withdrawalAmount, addressWithETH);
-            })().catch(done);
-        });
-        it('should cancel outstanding subscriptions when ZeroEx.setProvider is called', (done: DoneCallback) => {
-            (async () => {
-                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
-                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-                        done(new Error('Expected this subscription to have been cancelled'));
-                    },
-                );
-                zeroEx.etherToken.subscribe(
-                    etherTokenAddress,
-                    EtherTokenEvents.Transfer,
-                    indexFilterValues,
-                    callbackNeverToBeCalled,
-                );
-                const callbackToBeCalled = reportNodeCallbackErrors(done)();
-                const newProvider = web3Factory.getRpcProvider();
-                zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
-                await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
-                zeroEx.etherToken.subscribe(
-                    etherTokenAddress,
-                    EtherTokenEvents.Transfer,
-                    indexFilterValues,
-                    callbackToBeCalled,
-                );
-                await zeroEx.token.transferAsync(
-                    etherTokenAddress,
-                    addressWithETH,
-                    addressWithoutFunds,
-                    transferAmount,
-                );
-            })().catch(done);
-        });
-        it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
-            (async () => {
-                const callbackNeverToBeCalled = 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(
-                    etherTokenAddress,
-                    EtherTokenEvents.Transfer,
-                    indexFilterValues,
-                    callbackNeverToBeCalled,
-                );
-                zeroEx.etherToken.unsubscribe(subscriptionToken);
-                await zeroEx.token.transferAsync(
-                    etherTokenAddress,
-                    addressWithETH,
-                    addressWithoutFunds,
-                    transferAmount,
-                );
-                done();
-            })().catch(done);
-        });
-    });
-    describe('#getLogsAsync', () => {
-        let etherTokenAddress: string;
-        let tokenTransferProxyAddress: string;
-        const blockRange: BlockRange = {
-            fromBlock: 0,
-            toBlock: BlockParamLiteral.Latest,
-        };
-        let txHash: string;
-        before(() => {
-            addressWithETH = userAddresses[0];
-            const tokenUtils = new TokenUtils(tokens);
-            const etherToken = tokenUtils.getWethTokenOrThrow();
-            etherTokenAddress = etherToken.address;
-            tokenTransferProxyAddress = zeroEx.proxy.getContractAddress();
-        });
-        it('should get logs with decoded args emitted by Approval', async () => {
-            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            const eventName = EtherTokenEvents.Approval;
-            const indexFilterValues = {};
-            const logs = await zeroEx.etherToken.getLogsAsync<ApprovalContractEventArgs>(
-                etherTokenAddress,
-                eventName,
-                blockRange,
-                indexFilterValues,
-            );
-            expect(logs).to.have.length(1);
-            const args = logs[0].args;
-            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);
-        });
-        it('should get logs with decoded args emitted by Deposit', async () => {
-            await zeroEx.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
-            const eventName = EtherTokenEvents.Deposit;
-            const indexFilterValues = {};
-            const logs = await zeroEx.etherToken.getLogsAsync<DepositContractEventArgs>(
-                etherTokenAddress,
-                eventName,
-                blockRange,
-                indexFilterValues,
-            );
-            expect(logs).to.have.length(1);
-            const args = logs[0].args;
-            expect(logs[0].event).to.be.equal(eventName);
-            expect(args._owner).to.be.equal(addressWithETH);
-            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);
-            const differentEventName = EtherTokenEvents.Transfer;
-            const indexFilterValues = {};
-            const logs = await zeroEx.etherToken.getLogsAsync(
-                etherTokenAddress,
-                differentEventName,
-                blockRange,
-                indexFilterValues,
-            );
-            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);
-            const eventName = EtherTokenEvents.Approval;
-            const indexFilterValues = {
-                _owner: addressWithETH,
-            };
-            const logs = await zeroEx.etherToken.getLogsAsync<ApprovalContractEventArgs>(
-                etherTokenAddress,
-                eventName,
-                blockRange,
-                indexFilterValues,
-            );
-            expect(logs).to.have.length(1);
-            const args = logs[0].args;
-            expect(args._owner).to.be.equal(addressWithETH);
-        });
-    });
 });

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

@@ -1,18 +1,19 @@
-import { web3Factory } from '@0xproject/dev-utils';
-import { LogEntry } from '@0xproject/types';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import 'mocha';
 import * as chai from 'chai';
 import * as _ from 'lodash';
-import 'mocha';
 import * as Sinon from 'sinon';
 import * as Web3 from 'web3';
-
-import { LogEvent } from '../src';
-import { EventWatcher } from '../src/order_watcher/event_watcher';
-import { DoneCallback } from '../src/types';
-
-import { chaiSetup } from './utils/chai_setup';
-import { reportNodeCallbackErrors } from './utils/report_callback_errors';
+import BigNumber from 'bignumber.js';
+import {chaiSetup} from './utils/chai_setup';
+import {web3Factory} from './utils/web3_factory';
+import {Web3Wrapper} from '../src/web3_wrapper';
+import {EventWatcher} from '../src/order_watcher/event_watcher';
+import {
+    ZeroEx,
+    LogEvent,
+    DecodedLogEvent,
+} from '../src';
+import {DoneCallback} from '../src/types';
 
 chaiSetup.configure();
 const expect = chai.expect;
@@ -22,7 +23,8 @@ describe('EventWatcher', () => {
     let stubs: Sinon.SinonStub[] = [];
     let eventWatcher: EventWatcher;
     let web3Wrapper: Web3Wrapper;
-    const logA: LogEntry = {
+    const numConfirmations = 0;
+    const logA: Web3.LogEntry = {
         address: '0x71d271f8b14adef568f8f28f1587ce7271ac4ca5',
         blockHash: null,
         blockNumber: null,
@@ -32,23 +34,23 @@ describe('EventWatcher', () => {
         transactionHash: '0x004881d38cd4a8f72f1a0d68c8b9b8124504706041ff37019c1d1ed6bfda8e17',
         transactionIndex: 0,
     };
-    const logB: LogEntry = {
+    const logB: Web3.LogEntry = {
         address: '0x8d12a197cb00d4747a1fe03395095ce2a5cc6819',
         blockHash: null,
         blockNumber: null,
         data: '',
         logIndex: null,
-        topics: ['0xf341246adaac6f497bc2a656f546ab9e182111d630394f0c57c710a59a2cb567'],
+        topics: [ '0xf341246adaac6f497bc2a656f546ab9e182111d630394f0c57c710a59a2cb567' ],
         transactionHash: '0x01ef3c048b18d9b09ea195b4ed94cf8dd5f3d857a1905ff886b152cfb1166f25',
         transactionIndex: 0,
     };
-    const logC: LogEntry = {
+    const logC: Web3.LogEntry = {
         address: '0x1d271f8b174adef58f1587ce68f8f27271ac4ca5',
         blockHash: null,
         blockNumber: null,
         data: '',
         logIndex: null,
-        topics: ['0xf341246adaac6f497bc2a656f546ab9e182111d630394f0c57c710a59a2cb567'],
+        topics: [ '0xf341246adaac6f497bc2a656f546ab9e182111d630394f0c57c710a59a2cb567' ],
         transactionHash: '0x01ef3c048b18d9b09ea195b4ed94cf8dd5f3d857a1905ff886b152cfb1166f25',
         transactionIndex: 0,
     };
@@ -65,7 +67,7 @@ describe('EventWatcher', () => {
         eventWatcher.unsubscribe();
     });
     it('correctly emits initial log events', (done: DoneCallback) => {
-        const logs: LogEntry[] = [logA, logB];
+        const logs: Web3.LogEntry[] = [logA, logB];
         const expectedLogEvents = [
             {
                 removed: false,
@@ -79,19 +81,18 @@ describe('EventWatcher', () => {
         const getLogsStub = Sinon.stub(web3Wrapper, 'getLogsAsync');
         getLogsStub.onCall(0).returns(logs);
         stubs.push(getLogsStub);
-        const expectedToBeCalledOnce = false;
-        const callback = reportNodeCallbackErrors(done, expectedToBeCalledOnce)((event: LogEvent) => {
+        const callback = (event: LogEvent) => {
             const expectedLogEvent = expectedLogEvents.shift();
             expect(event).to.be.deep.equal(expectedLogEvent);
             if (_.isEmpty(expectedLogEvents)) {
                 done();
             }
-        });
+        };
         eventWatcher.subscribe(callback);
     });
     it('correctly computes the difference and emits only changes', (done: DoneCallback) => {
-        const initialLogs: LogEntry[] = [logA, logB];
-        const changedLogs: LogEntry[] = [logA, logC];
+        const initialLogs: Web3.LogEntry[] = [logA, logB];
+        const changedLogs: Web3.LogEntry[] = [logA, logC];
         const expectedLogEvents = [
             {
                 removed: false,
@@ -114,14 +115,13 @@ describe('EventWatcher', () => {
         getLogsStub.onCall(0).returns(initialLogs);
         getLogsStub.onCall(1).returns(changedLogs);
         stubs.push(getLogsStub);
-        const expectedToBeCalledOnce = false;
-        const callback = reportNodeCallbackErrors(done, expectedToBeCalledOnce)((event: LogEvent) => {
+        const callback = (event: LogEvent) => {
             const expectedLogEvent = expectedLogEvents.shift();
             expect(event).to.be.deep.equal(expectedLogEvent);
             if (_.isEmpty(expectedLogEvents)) {
                 done();
             }
-        });
+        };
         eventWatcher.subscribe(callback);
     });
 });

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

@@ -1,25 +1,19 @@
-import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
-import { BlockParamLiteral } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
-
-import { ExchangeContractErrs, Token, ZeroEx } from '../src';
-import { TradeSide, TransferType } from '../src/types';
-import { ExchangeTransferSimulator } from '../src/utils/exchange_transfer_simulator';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
-import { web3, web3Wrapper } from './utils/web3_wrapper';
+import BigNumber from 'bignumber.js';
+import {chaiSetup} from './utils/chai_setup';
+import {web3Factory} from './utils/web3_factory';
+import {ZeroEx, ExchangeContractErrs, Token} from '../src';
+import {TradeSide, TransferType} from '../src/types';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
+import {ExchangeTransferSimulator} from '../src/utils/exchange_transfer_simulator';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+const blockchainLifecycle = new BlockchainLifecycle();
 
 describe('ExchangeTransferSimulator', () => {
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
-    const zeroEx = new ZeroEx(web3.currentProvider, config);
+    const web3 = web3Factory.create();
+    const zeroEx = new ZeroEx(web3.currentProvider);
     const transferAmount = new BigNumber(5);
     let userAddresses: string[];
     let tokens: Token[];
@@ -43,33 +37,19 @@ describe('ExchangeTransferSimulator', () => {
     });
     describe('#transferFromAsync', () => {
         beforeEach(() => {
-            exchangeTransferSimulator = new ExchangeTransferSimulator(zeroEx.token, BlockParamLiteral.Latest);
+            exchangeTransferSimulator = new ExchangeTransferSimulator(zeroEx.token);
         });
-        it("throws if the user doesn't have enough allowance", async () => {
-            return expect(
-                exchangeTransferSimulator.transferFromAsync(
-                    exampleTokenAddress,
-                    sender,
-                    recipient,
-                    transferAmount,
-                    TradeSide.Taker,
-                    TransferType.Trade,
-                ),
-            ).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerAllowance);
+        it('throws if the user doesn\'t have enough allowance', async () => {
+            return expect(exchangeTransferSimulator.transferFromAsync(
+                exampleTokenAddress, sender, recipient, transferAmount, TradeSide.Taker, TransferType.Trade,
+            )).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerAllowance);
         });
-        it("throws if the user doesn't have enough balance", async () => {
+        it('throws if the user doesn\'t have enough balance', async () => {
             txHash = await zeroEx.token.setProxyAllowanceAsync(exampleTokenAddress, sender, transferAmount);
             await zeroEx.awaitTransactionMinedAsync(txHash);
-            return expect(
-                exchangeTransferSimulator.transferFromAsync(
-                    exampleTokenAddress,
-                    sender,
-                    recipient,
-                    transferAmount,
-                    TradeSide.Maker,
-                    TransferType.Trade,
-                ),
-            ).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerBalance);
+            return expect(exchangeTransferSimulator.transferFromAsync(
+                exampleTokenAddress, sender, recipient, transferAmount, TradeSide.Maker, TransferType.Trade,
+            )).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerBalance);
         });
         it('updates balances and proxyAllowance after transfer', async () => {
             txHash = await zeroEx.token.transferAsync(exampleTokenAddress, coinbase, sender, transferAmount);
@@ -77,14 +57,9 @@ describe('ExchangeTransferSimulator', () => {
             txHash = await zeroEx.token.setProxyAllowanceAsync(exampleTokenAddress, sender, transferAmount);
             await zeroEx.awaitTransactionMinedAsync(txHash);
             await exchangeTransferSimulator.transferFromAsync(
-                exampleTokenAddress,
-                sender,
-                recipient,
-                transferAmount,
-                TradeSide.Taker,
-                TransferType.Trade,
+                exampleTokenAddress, sender, recipient, transferAmount, TradeSide.Taker, TransferType.Trade,
             );
-            const store = (exchangeTransferSimulator as any)._store;
+            const store = (exchangeTransferSimulator as any).store;
             const senderBalance = await store.getBalanceAsync(exampleTokenAddress, sender);
             const recipientBalance = await store.getBalanceAsync(exampleTokenAddress, recipient);
             const senderProxyAllowance = await store.getProxyAllowanceAsync(exampleTokenAddress, sender);
@@ -92,20 +67,15 @@ describe('ExchangeTransferSimulator', () => {
             expect(recipientBalance).to.be.bignumber.equal(transferAmount);
             expect(senderProxyAllowance).to.be.bignumber.equal(0);
         });
-        it("doesn't update proxyAllowance after transfer if unlimited", async () => {
+        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);
             await exchangeTransferSimulator.transferFromAsync(
-                exampleTokenAddress,
-                sender,
-                recipient,
-                transferAmount,
-                TradeSide.Taker,
-                TransferType.Trade,
+                exampleTokenAddress, sender, recipient, transferAmount, TradeSide.Taker, TransferType.Trade,
             );
-            const store = (exchangeTransferSimulator as any)._store;
+            const store = (exchangeTransferSimulator as any).store;
             const senderBalance = await store.getBalanceAsync(exampleTokenAddress, sender);
             const recipientBalance = await store.getBalanceAsync(exampleTokenAddress, recipient);
             const senderProxyAllowance = await store.getProxyAllowanceAsync(exampleTokenAddress, sender);

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

@@ -1,28 +1,27 @@
-import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
-import { BigNumber } from '@0xproject/utils';
+import 'mocha';
 import * as chai from 'chai';
 import * as _ from 'lodash';
-import 'mocha';
 import * as Sinon from 'sinon';
 import * as Web3 from 'web3';
-
-import { ZeroEx } from '../src/0x';
-import { ExpirationWatcher } from '../src/order_watcher/expiration_watcher';
-import { DoneCallback, Token } from '../src/types';
-import { utils } from '../src/utils/utils';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
-import { FillScenarios } from './utils/fill_scenarios';
-import { reportNoErrorCallbackErrors } from './utils/report_callback_errors';
-import { TokenUtils } from './utils/token_utils';
-import { web3, web3Wrapper } from './utils/web3_wrapper';
+import BigNumber from 'bignumber.js';
+import {chaiSetup} from './utils/chai_setup';
+import {web3Factory} from './utils/web3_factory';
+import {utils} from '../src/utils/utils';
+import {Web3Wrapper} from '../src/web3_wrapper';
+import {TokenUtils} from './utils/token_utils';
+import {ExpirationWatcher} from '../src/order_watcher/expiration_watcher';
+import {Token, DoneCallback} from '../src/types';
+import {ZeroEx} from '../src/0x';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
+import {FillScenarios} from './utils/fill_scenarios';
+import {reportCallbackErrors} from './utils/report_callback_errors';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+const blockchainLifecycle = new BlockchainLifecycle();
 
 describe('ExpirationWatcher', () => {
+    let web3: Web3;
     let zeroEx: ZeroEx;
     let tokenUtils: TokenUtils;
     let tokens: Token[];
@@ -41,11 +40,9 @@ describe('ExpirationWatcher', () => {
     let timer: Sinon.SinonFakeTimers;
     let expirationWatcher: ExpirationWatcher;
     before(async () => {
-        const config = {
-            networkId: constants.TESTRPC_NETWORK_ID,
-        };
-        zeroEx = new ZeroEx(web3.currentProvider, config);
-        exchangeContractAddress = zeroEx.exchange.getContractAddress();
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider);
+        exchangeContractAddress = await zeroEx.exchange.getContractAddressAsync();
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
         tokenUtils = new TokenUtils(tokens);
@@ -53,13 +50,13 @@ describe('ExpirationWatcher', () => {
         fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
         [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
-        const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+        const [makerToken, takerToken] = tokenUtils.getNonProtocolTokens();
         makerTokenAddress = makerToken.address;
         takerTokenAddress = takerToken.address;
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
-        const sinonTimerConfig = { shouldAdvanceTime: true } as any;
+        const sinonTimerConfig = {shouldAdvanceTime: true} as any;
         // This constructor has incorrect types
         timer = Sinon.useFakeTimers(sinonTimerConfig);
         currentUnixTimestampSec = utils.getCurrentUnixTimestampSec();
@@ -75,38 +72,31 @@ describe('ExpirationWatcher', () => {
             const orderLifetimeSec = 60;
             const expirationUnixTimestampSec = currentUnixTimestampSec.plus(orderLifetimeSec);
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 expirationUnixTimestampSec,
             );
             const orderHash = ZeroEx.getOrderHashHex(signedOrder);
             expirationWatcher.addOrder(orderHash, signedOrder.expirationUnixTimestampSec.times(1000));
-            const callbackAsync = reportNoErrorCallbackErrors(done)((hash: string) => {
+            const callbackAsync = reportCallbackErrors(done)(async (hash: string) => {
                 expect(hash).to.be.equal(orderHash);
                 expect(utils.getCurrentUnixTimestampSec()).to.be.bignumber.gte(expirationUnixTimestampSec);
+                done();
             });
             expirationWatcher.subscribe(callbackAsync);
             timer.tick(orderLifetimeSec * 1000);
         })().catch(done);
     });
-    it("doesn't emit events before order expires", (done: DoneCallback) => {
+    it('doesn\'t emit events before order expires', (done: DoneCallback) => {
         (async () => {
             const orderLifetimeSec = 60;
             const expirationUnixTimestampSec = currentUnixTimestampSec.plus(orderLifetimeSec);
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 expirationUnixTimestampSec,
             );
             const orderHash = ZeroEx.getOrderHashHex(signedOrder);
             expirationWatcher.addOrder(orderHash, signedOrder.expirationUnixTimestampSec.times(1000));
-            const callbackAsync = reportNoErrorCallbackErrors(done)(async (hash: string) => {
+            const callbackAsync = reportCallbackErrors(done)(async (hash: string) => {
                 done(new Error('Emitted expiration went before the order actually expired'));
             });
             expirationWatcher.subscribe(callbackAsync);
@@ -122,19 +112,11 @@ describe('ExpirationWatcher', () => {
             const order1ExpirationUnixTimestampSec = currentUnixTimestampSec.plus(order1Lifetime);
             const order2ExpirationUnixTimestampSec = currentUnixTimestampSec.plus(order2Lifetime);
             const signedOrder1 = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 order1ExpirationUnixTimestampSec,
             );
             const signedOrder2 = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 order2ExpirationUnixTimestampSec,
             );
             const orderHash1 = ZeroEx.getOrderHashHex(signedOrder1);
@@ -142,8 +124,7 @@ describe('ExpirationWatcher', () => {
             expirationWatcher.addOrder(orderHash2, signedOrder2.expirationUnixTimestampSec.times(1000));
             expirationWatcher.addOrder(orderHash1, signedOrder1.expirationUnixTimestampSec.times(1000));
             const expirationOrder = [orderHash1, orderHash2];
-            const expectToBeCalledOnce = false;
-            const callbackAsync = reportNoErrorCallbackErrors(done, expectToBeCalledOnce)((hash: string) => {
+            const callbackAsync = reportCallbackErrors(done)(async (hash: string) => {
                 const orderHash = expirationOrder.shift();
                 expect(hash).to.be.equal(orderHash);
                 if (_.isEmpty(expirationOrder)) {

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

@@ -1,37 +1,39 @@
-import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
-import { BigNumber } from '@0xproject/utils';
+import 'mocha';
 import * as chai from 'chai';
 import * as _ from 'lodash';
-import 'mocha';
 import * as Web3 from 'web3';
-
+import BigNumber from 'bignumber.js';
+import { chaiSetup } from './utils/chai_setup';
+import { web3Factory } from './utils/web3_factory';
+import { Web3Wrapper } from '../src/web3_wrapper';
+import { OrderStateWatcher } from '../src/order_watcher/order_state_watcher';
 import {
-    ExchangeContractErrs,
-    OrderState,
-    OrderStateInvalid,
-    OrderStateValid,
-    SignedOrder,
     Token,
     ZeroEx,
+    LogEvent,
+    DecodedLogEvent,
+    ZeroExConfig,
+    OrderState,
+    SignedOrder,
     ZeroExError,
+    OrderStateValid,
+    OrderStateInvalid,
+    ExchangeContractErrs,
 } from '../src';
-import { OrderStateWatcher } from '../src/order_watcher/order_state_watcher';
-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 { web3, web3Wrapper } from './utils/web3_wrapper';
+import { FillScenarios } from './utils/fill_scenarios';
+import { DoneCallback } from '../src/types';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
+import {reportCallbackErrors} from './utils/report_callback_errors';
 
 const TIMEOUT_MS = 150;
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+const blockchainLifecycle = new BlockchainLifecycle();
 
 describe('OrderStateWatcher', () => {
+    let web3: Web3;
     let zeroEx: ZeroEx;
     let tokens: Token[];
     let tokenUtils: TokenUtils;
@@ -43,25 +45,21 @@ describe('OrderStateWatcher', () => {
     let takerToken: Token;
     let maker: string;
     let taker: string;
+    let web3Wrapper: Web3Wrapper;
     let signedOrder: SignedOrder;
-    let orderStateWatcher: OrderStateWatcher;
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
-    const decimals = constants.ZRX_DECIMALS;
-    const fillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals);
+    const fillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(5), 18);
     before(async () => {
-        zeroEx = new ZeroEx(web3.currentProvider, config);
-        orderStateWatcher = zeroEx.createOrderStateWatcher();
-        exchangeContractAddress = zeroEx.exchange.getContractAddress();
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider);
+        exchangeContractAddress = await zeroEx.exchange.getContractAddressAsync();
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         [, maker, taker] = userAddresses;
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
         tokenUtils = new TokenUtils(tokens);
         zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
         fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
-        await fillScenarios.initTokenBalancesAsync();
-        [makerToken, takerToken] = tokenUtils.getDummyTokens();
+        [makerToken, takerToken] = tokenUtils.getNonProtocolTokens();
+        web3Wrapper = (zeroEx as any)._web3Wrapper;
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
@@ -72,96 +70,80 @@ describe('OrderStateWatcher', () => {
     describe('#removeOrder', async () => {
         it('should successfully remove existing order', async () => {
             signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerToken.address,
-                takerToken.address,
-                maker,
-                taker,
-                fillableAmount,
+                makerToken.address, takerToken.address, maker, taker, fillableAmount,
             );
             const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-            orderStateWatcher.addOrder(signedOrder);
-            expect((orderStateWatcher as any)._orderByOrderHash).to.include({
+            await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
+            expect((zeroEx.orderStateWatcher as any)._orderByOrderHash).to.include({
                 [orderHash]: signedOrder,
             });
-            let dependentOrderHashes = (orderStateWatcher as any)._dependentOrderHashes;
+            let dependentOrderHashes = (zeroEx.orderStateWatcher as any)._dependentOrderHashes;
             expect(dependentOrderHashes[signedOrder.maker][signedOrder.makerTokenAddress]).to.have.keys(orderHash);
-            orderStateWatcher.removeOrder(orderHash);
-            expect((orderStateWatcher as any)._orderByOrderHash).to.not.include({
+            await zeroEx.orderStateWatcher.removeOrderAsync(orderHash);
+            expect((zeroEx.orderStateWatcher as any)._orderByOrderHash).to.not.include({
                 [orderHash]: signedOrder,
             });
-            dependentOrderHashes = (orderStateWatcher as any)._dependentOrderHashes;
+            dependentOrderHashes = (zeroEx.orderStateWatcher as any)._dependentOrderHashes;
             expect(dependentOrderHashes[signedOrder.maker]).to.be.undefined();
         });
         it('should no-op when removing a non-existing order', async () => {
             signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerToken.address,
-                takerToken.address,
-                maker,
-                taker,
-                fillableAmount,
+                makerToken.address, takerToken.address, maker, taker, fillableAmount,
             );
             const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-            const nonExistentOrderHash = `0x${orderHash
-                .substr(2)
-                .split('')
-                .reverse()
-                .join('')}`;
-            orderStateWatcher.removeOrder(nonExistentOrderHash);
+            const nonExistentOrderHash = `0x${orderHash.substr(2).split('').reverse().join('')}`;
+            await zeroEx.orderStateWatcher.removeOrderAsync(nonExistentOrderHash);
         });
     });
     describe('#subscribe', async () => {
         afterEach(async () => {
-            orderStateWatcher.unsubscribe();
+            zeroEx.orderStateWatcher.unsubscribe();
         });
         it('should fail when trying to subscribe twice', async () => {
-            orderStateWatcher.subscribe(_.noop);
-            expect(() => orderStateWatcher.subscribe(_.noop)).to.throw(ZeroExError.SubscriptionAlreadyPresent);
+            zeroEx.orderStateWatcher.subscribe(_.noop);
+            expect(() => zeroEx.orderStateWatcher.subscribe(_.noop))
+                .to.throw(ZeroExError.SubscriptionAlreadyPresent);
         });
     });
     describe('tests with cleanup', async () => {
         afterEach(async () => {
-            orderStateWatcher.unsubscribe();
+            zeroEx.orderStateWatcher.unsubscribe();
             const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-            orderStateWatcher.removeOrder(orderHash);
+            await zeroEx.orderStateWatcher.removeOrderAsync(orderHash);
         });
         it('should emit orderStateInvalid when maker allowance set to 0 for watched order', (done: DoneCallback) => {
             (async () => {
                 signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
+                    makerToken.address, takerToken.address, maker, taker, fillableAmount,
                 );
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                orderStateWatcher.addOrder(signedOrder);
-                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
                     expect(orderState.isValid).to.be.false();
                     const invalidOrderState = orderState as OrderStateInvalid;
                     expect(invalidOrderState.orderHash).to.be.equal(orderHash);
                     expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.InsufficientMakerAllowance);
+                    done();
                 });
-                orderStateWatcher.subscribe(callback);
+                zeroEx.orderStateWatcher.subscribe(callback);
                 await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, new BigNumber(0));
             })().catch(done);
         });
         it('should not emit an orderState event when irrelevant Transfer event received', (done: DoneCallback) => {
             (async () => {
                 signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
+                    makerToken.address, takerToken.address, maker, taker, fillableAmount,
                 );
-                orderStateWatcher.addOrder(signedOrder);
-                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
                     throw new Error('OrderState callback fired for irrelevant order');
                 });
-                orderStateWatcher.subscribe(callback);
+                zeroEx.orderStateWatcher.subscribe(callback);
                 const notTheMaker = userAddresses[0];
                 const anyRecipient = taker;
                 const transferAmount = new BigNumber(2);
+                const notTheMakerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, notTheMaker);
                 await zeroEx.token.transferAsync(makerToken.address, notTheMaker, anyRecipient, transferAmount);
                 setTimeout(() => {
                     done();
@@ -171,21 +153,18 @@ describe('OrderStateWatcher', () => {
         it('should emit orderStateInvalid when maker moves balance backing watched order', (done: DoneCallback) => {
             (async () => {
                 signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
+                    makerToken.address, takerToken.address, maker, taker, fillableAmount,
                 );
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                orderStateWatcher.addOrder(signedOrder);
-                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
                     expect(orderState.isValid).to.be.false();
                     const invalidOrderState = orderState as OrderStateInvalid;
                     expect(invalidOrderState.orderHash).to.be.equal(orderHash);
                     expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.InsufficientMakerBalance);
+                    done();
                 });
-                orderStateWatcher.subscribe(callback);
+                zeroEx.orderStateWatcher.subscribe(callback);
                 const anyRecipient = taker;
                 const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
                 await zeroEx.token.transferAsync(makerToken.address, maker, anyRecipient, makerBalance);
@@ -194,48 +173,46 @@ describe('OrderStateWatcher', () => {
         it('should emit orderStateInvalid when watched order fully filled', (done: DoneCallback) => {
             (async () => {
                 signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
+                    makerToken.address, takerToken.address, maker, taker, fillableAmount,
                 );
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                orderStateWatcher.addOrder(signedOrder);
+                await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
 
-                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                let eventCount = 0;
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                    eventCount++;
                     expect(orderState.isValid).to.be.false();
                     const invalidOrderState = orderState as OrderStateInvalid;
                     expect(invalidOrderState.orderHash).to.be.equal(orderHash);
                     expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
+                    if (eventCount === 2) {
+                        done();
+                    }
                 });
-                orderStateWatcher.subscribe(callback);
+                zeroEx.orderStateWatcher.subscribe(callback);
 
                 const shouldThrowOnInsufficientBalanceOrAllowance = true;
                 await zeroEx.exchange.fillOrderAsync(
-                    signedOrder,
-                    fillableAmount,
-                    shouldThrowOnInsufficientBalanceOrAllowance,
-                    taker,
+                    signedOrder, fillableAmount, shouldThrowOnInsufficientBalanceOrAllowance, taker,
                 );
             })().catch(done);
         });
         it('should emit orderStateValid when watched order partially filled', (done: DoneCallback) => {
             (async () => {
                 signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
+                    makerToken.address, takerToken.address, maker, taker, fillableAmount,
                 );
 
                 const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
+                const takerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, taker);
+
                 const fillAmountInBaseUnits = new BigNumber(2);
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                orderStateWatcher.addOrder(signedOrder);
+                await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
 
-                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                let eventCount = 0;
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                    eventCount++;
                     expect(orderState.isValid).to.be.true();
                     const validOrderState = orderState as OrderStateValid;
                     expect(validOrderState.orderHash).to.be.equal(orderHash);
@@ -243,20 +220,18 @@ describe('OrderStateWatcher', () => {
                     const remainingMakerBalance = makerBalance.sub(fillAmountInBaseUnits);
                     const remainingFillable = fillableAmount.minus(fillAmountInBaseUnits);
                     expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                        remainingFillable,
-                    );
+                        remainingFillable);
                     expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
-                        remainingFillable,
-                    );
+                        remainingFillable);
                     expect(orderRelevantState.makerBalance).to.be.bignumber.equal(remainingMakerBalance);
+                    if (eventCount === 2) {
+                        done();
+                    }
                 });
-                orderStateWatcher.subscribe(callback);
+                zeroEx.orderStateWatcher.subscribe(callback);
                 const shouldThrowOnInsufficientBalanceOrAllowance = true;
                 await zeroEx.exchange.fillOrderAsync(
-                    signedOrder,
-                    fillAmountInBaseUnits,
-                    shouldThrowOnInsufficientBalanceOrAllowance,
-                    taker,
+                    signedOrder, fillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, taker,
                 );
             })().catch(done);
         });
@@ -265,242 +240,122 @@ describe('OrderStateWatcher', () => {
                 const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(2), 18);
                 const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), 18);
                 signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    makerFee,
-                    takerFee,
-                    maker,
-                    taker,
-                    fillableAmount,
-                    taker,
-                );
-                const callback = reportNodeCallbackErrors(done)();
-                orderStateWatcher.addOrder(signedOrder);
-                orderStateWatcher.subscribe(callback);
+                    makerToken.address, takerToken.address, makerFee, takerFee, maker, taker, fillableAmount,
+                    taker);
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                    done();
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
                 await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, maker, new BigNumber(0));
             })().catch(done);
         });
         describe('remainingFillable(M|T)akerTokenAmount', () => {
             it('should calculate correct remaining fillable', (done: DoneCallback) => {
                 (async () => {
-                    const takerFillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(10), decimals);
-                    const makerFillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(20), decimals);
+                    const takerFillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(10), 18);
+                    const makerFillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(20), 18);
                     signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
-                        makerToken.address,
-                        takerToken.address,
-                        maker,
-                        taker,
-                        makerFillableAmount,
+                        makerToken.address, takerToken.address, maker, taker, makerFillableAmount,
                         takerFillableAmount,
                     );
-                    const fillAmountInBaseUnits = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
+                    const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
+                    const takerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, taker);
+                    const fillAmountInBaseUnits = ZeroEx.toBaseUnitAmount(new BigNumber(2), 18);
                     const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                    orderStateWatcher.addOrder(signedOrder);
-                    const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                    await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
+                    let eventCount = 0;
+                    const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                        eventCount++;
                         expect(orderState.isValid).to.be.true();
                         const validOrderState = orderState as OrderStateValid;
                         expect(validOrderState.orderHash).to.be.equal(orderHash);
                         const orderRelevantState = validOrderState.orderRelevantState;
                         expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                            ZeroEx.toBaseUnitAmount(new BigNumber(16), decimals),
-                        );
+                            ZeroEx.toBaseUnitAmount(new BigNumber(16), 18));
                         expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
-                            ZeroEx.toBaseUnitAmount(new BigNumber(8), decimals),
-                        );
+                            ZeroEx.toBaseUnitAmount(new BigNumber(8), 18));
+                        if (eventCount === 2) {
+                            done();
+                        }
                     });
-                    orderStateWatcher.subscribe(callback);
+                    zeroEx.orderStateWatcher.subscribe(callback);
                     const shouldThrowOnInsufficientBalanceOrAllowance = true;
                     await zeroEx.exchange.fillOrderAsync(
-                        signedOrder,
-                        fillAmountInBaseUnits,
-                        shouldThrowOnInsufficientBalanceOrAllowance,
-                        taker,
+                        signedOrder, fillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, taker,
                     );
                 })().catch(done);
             });
             it('should equal approved amount when approved amount is lowest', (done: DoneCallback) => {
                 (async () => {
                     signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                        makerToken.address,
-                        takerToken.address,
-                        maker,
-                        taker,
-                        fillableAmount,
+                        makerToken.address, takerToken.address, maker, taker, fillableAmount,
                     );
 
-                    const changedMakerApprovalAmount = ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals);
-                    orderStateWatcher.addOrder(signedOrder);
+                    const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
 
-                    const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                    const changedMakerApprovalAmount = ZeroEx.toBaseUnitAmount(new BigNumber(3), 18);
+                    await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
+
+                    const callback = reportCallbackErrors(done)((orderState: OrderState) => {
                         const validOrderState = orderState as OrderStateValid;
                         const orderRelevantState = validOrderState.orderRelevantState;
                         expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                            changedMakerApprovalAmount,
-                        );
+                            changedMakerApprovalAmount);
                         expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
-                            changedMakerApprovalAmount,
-                        );
+                            changedMakerApprovalAmount);
+                        done();
                     });
-                    orderStateWatcher.subscribe(callback);
+                    zeroEx.orderStateWatcher.subscribe(callback);
                     await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, changedMakerApprovalAmount);
                 })().catch(done);
             });
             it('should equal balance amount when balance amount is lowest', (done: DoneCallback) => {
                 (async () => {
                     signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                        makerToken.address,
-                        takerToken.address,
-                        maker,
-                        taker,
-                        fillableAmount,
+                        makerToken.address, takerToken.address, maker, taker, fillableAmount,
                     );
 
                     const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
 
-                    const remainingAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals);
+                    const remainingAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), 18);
                     const transferAmount = makerBalance.sub(remainingAmount);
-                    orderStateWatcher.addOrder(signedOrder);
+                    await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
 
-                    const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-                        expect(orderState.isValid).to.be.true();
+                    const callback = reportCallbackErrors(done)((orderState: OrderState) => {
                         const validOrderState = orderState as OrderStateValid;
                         const orderRelevantState = validOrderState.orderRelevantState;
                         expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                            remainingAmount,
-                        );
+                            remainingAmount);
                         expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
-                            remainingAmount,
-                        );
+                            remainingAmount);
+                        done();
                     });
-                    orderStateWatcher.subscribe(callback);
-                    await zeroEx.token.transferAsync(makerToken.address, maker, ZeroEx.NULL_ADDRESS, transferAmount);
-                })().catch(done);
-            });
-            it('should equal remaining amount when partially cancelled and order has fees', (done: DoneCallback) => {
-                (async () => {
-                    const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), decimals);
-                    const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals);
-                    const feeRecipient = taker;
-                    signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-                        makerToken.address,
-                        takerToken.address,
-                        makerFee,
-                        takerFee,
-                        maker,
-                        taker,
-                        fillableAmount,
-                        feeRecipient,
-                    );
-
-                    const remainingTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(4), decimals);
-                    const transferTokenAmount = makerFee.sub(remainingTokenAmount);
-                    orderStateWatcher.addOrder(signedOrder);
-
-                    const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-                        expect(orderState.isValid).to.be.true();
-                        const validOrderState = orderState as OrderStateValid;
-                        const orderRelevantState = validOrderState.orderRelevantState;
-                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                            remainingTokenAmount,
-                        );
-                    });
-                    orderStateWatcher.subscribe(callback);
-                    await zeroEx.exchange.cancelOrderAsync(signedOrder, transferTokenAmount);
-                })().catch(done);
-            });
-            it('should equal ratio amount when fee balance is lowered', (done: DoneCallback) => {
-                (async () => {
-                    const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), decimals);
-                    const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals);
-                    const feeRecipient = taker;
-                    signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-                        makerToken.address,
-                        takerToken.address,
-                        makerFee,
-                        takerFee,
-                        maker,
-                        taker,
-                        fillableAmount,
-                        feeRecipient,
-                    );
-
-                    const remainingFeeAmount = ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals);
-
-                    const remainingTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(4), decimals);
-                    const transferTokenAmount = makerFee.sub(remainingTokenAmount);
-                    orderStateWatcher.addOrder(signedOrder);
-
-                    const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-                        const validOrderState = orderState as OrderStateValid;
-                        const orderRelevantState = validOrderState.orderRelevantState;
-                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                            remainingFeeAmount,
-                        );
-                    });
-                    orderStateWatcher.subscribe(callback);
-                    await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, maker, remainingFeeAmount);
+                    zeroEx.orderStateWatcher.subscribe(callback);
                     await zeroEx.token.transferAsync(
-                        makerToken.address,
-                        maker,
-                        ZeroEx.NULL_ADDRESS,
-                        transferTokenAmount,
-                    );
-                })().catch(done);
-            });
-            it('should calculate full amount when all available and non-divisible', (done: DoneCallback) => {
-                (async () => {
-                    const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), decimals);
-                    const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-                    const feeRecipient = taker;
-                    signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-                        makerToken.address,
-                        takerToken.address,
-                        makerFee,
-                        takerFee,
-                        maker,
-                        taker,
-                        fillableAmount,
-                        feeRecipient,
-                    );
-
-                    orderStateWatcher.addOrder(signedOrder);
-
-                    const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-                        const validOrderState = orderState as OrderStateValid;
-                        const orderRelevantState = validOrderState.orderRelevantState;
-                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                            fillableAmount,
-                        );
-                    });
-                    orderStateWatcher.subscribe(callback);
-                    await zeroEx.token.setProxyAllowanceAsync(
-                        makerToken.address,
-                        maker,
-                        ZeroEx.toBaseUnitAmount(new BigNumber(100), decimals),
-                    );
+                        makerToken.address, maker, ZeroEx.NULL_ADDRESS, transferAmount);
                 })().catch(done);
             });
         });
         it('should emit orderStateInvalid when watched order cancelled', (done: DoneCallback) => {
             (async () => {
                 signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
+                    makerToken.address, takerToken.address, maker, taker, fillableAmount,
                 );
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                orderStateWatcher.addOrder(signedOrder);
+                await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
 
-                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
                     expect(orderState.isValid).to.be.false();
                     const invalidOrderState = orderState as OrderStateInvalid;
                     expect(invalidOrderState.orderHash).to.be.equal(orderHash);
                     expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
+                    done();
                 });
-                orderStateWatcher.subscribe(callback);
+                zeroEx.orderStateWatcher.subscribe(callback);
 
+                const shouldThrowOnInsufficientBalanceOrAllowance = true;
                 await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
             })().catch(done);
         });
@@ -508,52 +363,48 @@ describe('OrderStateWatcher', () => {
             (async () => {
                 const remainingFillableAmountInBaseUnits = new BigNumber(100);
                 signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
+                    makerToken.address, takerToken.address, maker, taker, fillableAmount,
                 );
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                orderStateWatcher.addOrder(signedOrder);
+                await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
 
-                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
                     expect(orderState.isValid).to.be.false();
                     const invalidOrderState = orderState as OrderStateInvalid;
                     expect(invalidOrderState.orderHash).to.be.equal(orderHash);
                     expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderFillRoundingError);
+                    done();
                 });
-                orderStateWatcher.subscribe(callback);
+                zeroEx.orderStateWatcher.subscribe(callback);
                 await zeroEx.exchange.cancelOrderAsync(
-                    signedOrder,
-                    fillableAmount.minus(remainingFillableAmountInBaseUnits),
+                    signedOrder, fillableAmount.minus(remainingFillableAmountInBaseUnits),
                 );
             })().catch(done);
         });
         it('should emit orderStateValid when watched order partially cancelled', (done: DoneCallback) => {
             (async () => {
                 signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
+                    makerToken.address, takerToken.address, maker, taker, fillableAmount,
                 );
 
+                const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
+                const takerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, taker);
+
                 const cancelAmountInBaseUnits = new BigNumber(2);
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                orderStateWatcher.addOrder(signedOrder);
+                await zeroEx.orderStateWatcher.addOrderAsync(signedOrder);
 
-                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
                     expect(orderState.isValid).to.be.true();
                     const validOrderState = orderState as OrderStateValid;
                     expect(validOrderState.orderHash).to.be.equal(orderHash);
                     const orderRelevantState = validOrderState.orderRelevantState;
                     expect(orderRelevantState.cancelledTakerTokenAmount).to.be.bignumber.equal(cancelAmountInBaseUnits);
+                    done();
                 });
-                orderStateWatcher.subscribe(callback);
+                zeroEx.orderStateWatcher.subscribe(callback);
                 await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmountInBaseUnits);
             })().catch(done);
         });
     });
-}); // tslint:disable:max-file-line-count
+});

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

@@ -1,26 +1,23 @@
-import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
-import { BlockParamLiteral } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
-import * as Sinon from 'sinon';
 import * as Web3 from 'web3';
-
-import { ExchangeContractErrs, SignedOrder, Token, ZeroEx, ZeroExError } 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 { web3, web3Wrapper } from './utils/web3_wrapper';
+import BigNumber from 'bignumber.js';
+import * as Sinon from 'sinon';
+import {chaiSetup} from './utils/chai_setup';
+import {web3Factory} from './utils/web3_factory';
+import {ZeroEx, SignedOrder, Token, ExchangeContractErrs, ZeroExError} from '../src';
+import {TradeSide, TransferType} from '../src/types';
+import {TokenUtils} from './utils/token_utils';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
+import {FillScenarios} from './utils/fill_scenarios';
+import {OrderValidationUtils} from '../src/utils/order_validation_utils';
+import {ExchangeTransferSimulator} from '../src/utils/exchange_transfer_simulator';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+const blockchainLifecycle = new BlockchainLifecycle();
 
 describe('OrderValidation', () => {
+    let web3: Web3;
     let zeroEx: ZeroEx;
     let userAddresses: string[];
     let tokens: Token[];
@@ -34,23 +31,23 @@ describe('OrderValidation', () => {
     let makerAddress: string;
     let takerAddress: string;
     let feeRecipient: string;
+    let orderValidationUtils: OrderValidationUtils;
     const fillableAmount = new BigNumber(5);
     const fillTakerAmount = new BigNumber(5);
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
     before(async () => {
-        zeroEx = new ZeroEx(web3.currentProvider, config);
-        exchangeContractAddress = zeroEx.exchange.getContractAddress();
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider);
+        exchangeContractAddress = await zeroEx.exchange.getContractAddressAsync();
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
         tokenUtils = new TokenUtils(tokens);
         zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
         fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
-        const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+        const [makerToken, takerToken] = tokenUtils.getNonProtocolTokens();
         makerTokenAddress = makerToken.address;
         takerTokenAddress = takerToken.address;
+        orderValidationUtils = new OrderValidationUtils(zeroEx.token, zeroEx.exchange);
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
@@ -61,152 +58,108 @@ describe('OrderValidation', () => {
     describe('validateOrderFillableOrThrowAsync', () => {
         it('should succeed if the order is fillable', async () => {
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
+            );
+            await zeroEx.exchange.validateOrderFillableOrThrowAsync(
+                signedOrder,
             );
-            await zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder);
         });
         it('should succeed if the order is asymmetric and fillable', async () => {
             const makerFillableAmount = fillableAmount;
             const takerFillableAmount = fillableAmount.minus(4);
             const signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                makerFillableAmount,
-                takerFillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
+                makerFillableAmount, takerFillableAmount,
+            );
+            await zeroEx.exchange.validateOrderFillableOrThrowAsync(
+                signedOrder,
             );
-            await zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder);
         });
         it('should throw when the order is fully filled or cancelled', async () => {
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
             );
             await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
-            return expect(zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder)).to.be.rejectedWith(
-                ExchangeContractErrs.OrderRemainingFillAmountZero,
-            );
+            return expect(zeroEx.exchange.validateOrderFillableOrThrowAsync(
+                signedOrder,
+            )).to.be.rejectedWith(ExchangeContractErrs.OrderRemainingFillAmountZero);
         });
         it('should throw when order is expired', async () => {
             const expirationInPast = new BigNumber(1496826058); // 7th Jun 2017
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
-                expirationInPast,
-            );
-            return expect(zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder)).to.be.rejectedWith(
-                ExchangeContractErrs.OrderFillExpired,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
+                fillableAmount, expirationInPast,
             );
+            return expect(zeroEx.exchange.validateOrderFillableOrThrowAsync(
+                signedOrder,
+            )).to.be.rejectedWith(ExchangeContractErrs.OrderFillExpired);
         });
     });
     describe('validateFillOrderAndThrowIfInvalidAsync', () => {
         it('should throw when the fill amount is zero', async () => {
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
             );
             const zeroFillAmount = new BigNumber(0);
-            return expect(
-                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, zeroFillAmount, takerAddress),
-            ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+            return expect(zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(
+                signedOrder, zeroFillAmount, takerAddress,
+            )).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
         });
         it('should throw when the signature is invalid', async () => {
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
             );
             // 27 <--> 28
-            signedOrder.ecSignature.v = 28 - signedOrder.ecSignature.v + 27;
-            return expect(
-                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillableAmount, takerAddress),
-            ).to.be.rejectedWith(ZeroExError.InvalidSignature);
+            signedOrder.ecSignature.v = 27 + (28 - signedOrder.ecSignature.v);
+            return expect(zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(
+                signedOrder, fillableAmount, takerAddress,
+            )).to.be.rejectedWith(ZeroExError.InvalidSignature);
         });
         it('should throw when the order is fully filled or cancelled', async () => {
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
             );
             await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
-            return expect(
-                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillableAmount, takerAddress),
-            ).to.be.rejectedWith(ExchangeContractErrs.OrderRemainingFillAmountZero);
+            return expect(zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(
+                signedOrder, fillableAmount, takerAddress,
+            )).to.be.rejectedWith(ExchangeContractErrs.OrderRemainingFillAmountZero);
         });
         it('should throw when sender is not a taker', async () => {
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
             );
             const nonTakerAddress = userAddresses[6];
-            return expect(
-                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillTakerAmount, nonTakerAddress),
-            ).to.be.rejectedWith(ExchangeContractErrs.TransactionSenderIsNotFillOrderTaker);
+            return expect(zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(
+                signedOrder, fillTakerAmount, nonTakerAddress,
+            )).to.be.rejectedWith(ExchangeContractErrs.TransactionSenderIsNotFillOrderTaker);
         });
         it('should throw when order is expired', async () => {
             const expirationInPast = new BigNumber(1496826058); // 7th Jun 2017
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
-                expirationInPast,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
+                fillableAmount, expirationInPast,
             );
-            return expect(
-                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillTakerAmount, takerAddress),
-            ).to.be.rejectedWith(ExchangeContractErrs.OrderFillExpired);
+            return expect(zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(
+                signedOrder, fillTakerAmount, takerAddress,
+            )).to.be.rejectedWith(ExchangeContractErrs.OrderFillExpired);
         });
         it('should throw when there a rounding error would have occurred', async () => {
             const makerAmount = new BigNumber(3);
             const takerAmount = new BigNumber(5);
             const signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                makerAmount,
-                takerAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
+                makerAmount, takerAmount,
             );
             const fillTakerAmountThatCausesRoundingError = new BigNumber(3);
-            return expect(
-                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(
-                    signedOrder,
-                    fillTakerAmountThatCausesRoundingError,
-                    takerAddress,
-                ),
-            ).to.be.rejectedWith(ExchangeContractErrs.OrderFillRoundingError);
+            return expect(zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(
+                signedOrder, fillTakerAmountThatCausesRoundingError, takerAddress,
+            )).to.be.rejectedWith(ExchangeContractErrs.OrderFillRoundingError);
         });
     });
     describe('#validateFillOrKillOrderAndThrowIfInvalidAsync', () => {
         it('should throw if remaining fillAmount is less then the desired fillAmount', async () => {
             const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
             );
             const tooLargeFillAmount = new BigNumber(7);
             const fillAmountDifference = tooLargeFillAmount.minus(fillableAmount);
@@ -215,56 +168,44 @@ describe('OrderValidation', () => {
             await zeroEx.token.transferAsync(makerTokenAddress, coinbase, makerAddress, fillAmountDifference);
             await zeroEx.token.setProxyAllowanceAsync(makerTokenAddress, makerAddress, tooLargeFillAmount);
 
-            return expect(
-                zeroEx.exchange.validateFillOrKillOrderThrowIfInvalidAsync(
-                    signedOrder,
-                    tooLargeFillAmount,
-                    takerAddress,
-                ),
-            ).to.be.rejectedWith(ExchangeContractErrs.InsufficientRemainingFillAmount);
+            return expect(zeroEx.exchange.validateFillOrKillOrderThrowIfInvalidAsync(
+                signedOrder, tooLargeFillAmount, takerAddress,
+            )).to.be.rejectedWith(ExchangeContractErrs.InsufficientRemainingFillAmount);
         });
     });
     describe('validateCancelOrderAndThrowIfInvalidAsync', () => {
         let signedOrder: SignedOrder;
+        let orderHashHex: string;
         const cancelAmount = new BigNumber(3);
         beforeEach(async () => {
             [coinbase, makerAddress, takerAddress] = userAddresses;
-            const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+            const [makerToken, takerToken] = tokenUtils.getNonProtocolTokens();
             makerTokenAddress = makerToken.address;
             takerTokenAddress = takerToken.address;
             signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
             );
+            orderHashHex = ZeroEx.getOrderHashHex(signedOrder);
         });
         it('should throw when cancel amount is zero', async () => {
             const zeroCancelAmount = new BigNumber(0);
-            return expect(
-                zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(signedOrder, zeroCancelAmount),
-            ).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+            return expect(zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(signedOrder, zeroCancelAmount))
+                .to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
         });
         it('should throw when order is expired', async () => {
             const expirationInPast = new BigNumber(1496826058); // 7th Jun 2017
             const expiredSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
-                expirationInPast,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
+                fillableAmount, expirationInPast,
             );
-            return expect(
-                zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(expiredSignedOrder, cancelAmount),
-            ).to.be.rejectedWith(ExchangeContractErrs.OrderCancelExpired);
+            orderHashHex = ZeroEx.getOrderHashHex(expiredSignedOrder);
+            return expect(zeroEx.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);
-            return expect(
-                zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(signedOrder, fillableAmount),
-            ).to.be.rejectedWith(ExchangeContractErrs.OrderAlreadyCancelledOrFilled);
+            return expect(zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(signedOrder, fillableAmount))
+                .to.be.rejectedWith(ExchangeContractErrs.OrderAlreadyCancelledOrFilled);
         });
     });
     describe('#validateFillOrderBalancesAllowancesThrowIfInvalidAsync', () => {
@@ -274,7 +215,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(zeroEx.token);
             transferFromAsync = Sinon.spy();
             exchangeTransferSimulator.transferFromAsync = transferFromAsync as any;
         });
@@ -282,159 +223,82 @@ describe('OrderValidation', () => {
             const makerFee = new BigNumber(2);
             const takerFee = new BigNumber(2);
             const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerFee,
-                takerFee,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
-                feeRecipient,
+                makerTokenAddress, takerTokenAddress, makerFee, takerFee,
+                makerAddress, takerAddress, fillableAmount, feeRecipient,
             );
-            await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
-                exchangeTransferSimulator,
-                signedOrder,
-                fillableAmount,
-                takerAddress,
-                zrxTokenAddress,
+            await orderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+                exchangeTransferSimulator, signedOrder, fillableAmount, takerAddress, zrxTokenAddress,
             );
             expect(transferFromAsync.callCount).to.be.equal(4);
             expect(
-                transferFromAsync
-                    .getCall(0)
-                    .calledWith(
-                        makerTokenAddress,
-                        makerAddress,
-                        takerAddress,
-                        bigNumberMatch(fillableAmount),
-                        TradeSide.Maker,
-                        TransferType.Trade,
-                    ),
+                transferFromAsync.getCall(0).calledWith(
+                    makerTokenAddress, makerAddress, takerAddress, bigNumberMatch(fillableAmount),
+                    TradeSide.Maker, TransferType.Trade,
+                ),
             ).to.be.true();
             expect(
-                transferFromAsync
-                    .getCall(1)
-                    .calledWith(
-                        takerTokenAddress,
-                        takerAddress,
-                        makerAddress,
-                        bigNumberMatch(fillableAmount),
-                        TradeSide.Taker,
-                        TransferType.Trade,
-                    ),
+                transferFromAsync.getCall(1).calledWith(
+                    takerTokenAddress, takerAddress, makerAddress, bigNumberMatch(fillableAmount),
+                    TradeSide.Taker, TransferType.Trade,
+                ),
             ).to.be.true();
             expect(
-                transferFromAsync
-                    .getCall(2)
-                    .calledWith(
-                        zrxTokenAddress,
-                        makerAddress,
-                        feeRecipient,
-                        bigNumberMatch(makerFee),
-                        TradeSide.Maker,
-                        TransferType.Fee,
-                    ),
+                transferFromAsync.getCall(2).calledWith(
+                    zrxTokenAddress, makerAddress, feeRecipient, bigNumberMatch(makerFee),
+                    TradeSide.Maker, TransferType.Fee,
+                ),
             ).to.be.true();
             expect(
-                transferFromAsync
-                    .getCall(3)
-                    .calledWith(
-                        zrxTokenAddress,
-                        takerAddress,
-                        feeRecipient,
-                        bigNumberMatch(takerFee),
-                        TradeSide.Taker,
-                        TransferType.Fee,
-                    ),
+                transferFromAsync.getCall(3).calledWith(
+                    zrxTokenAddress, takerAddress, feeRecipient, bigNumberMatch(takerFee),
+                    TradeSide.Taker, TransferType.Fee,
+                ),
             ).to.be.true();
         });
         it('should call exchangeTransferSimulator.transferFrom with correct values for an open order', async () => {
             const makerFee = new BigNumber(2);
             const takerFee = new BigNumber(2);
             const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerFee,
-                takerFee,
-                makerAddress,
-                ZeroEx.NULL_ADDRESS,
-                fillableAmount,
-                feeRecipient,
+                makerTokenAddress, takerTokenAddress, makerFee, takerFee,
+                makerAddress, ZeroEx.NULL_ADDRESS, fillableAmount, feeRecipient,
             );
-            await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
-                exchangeTransferSimulator,
-                signedOrder,
-                fillableAmount,
-                takerAddress,
-                zrxTokenAddress,
+            await orderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+                exchangeTransferSimulator, signedOrder, fillableAmount, takerAddress, zrxTokenAddress,
             );
             expect(transferFromAsync.callCount).to.be.equal(4);
             expect(
-                transferFromAsync
-                    .getCall(0)
-                    .calledWith(
-                        makerTokenAddress,
-                        makerAddress,
-                        takerAddress,
-                        bigNumberMatch(fillableAmount),
-                        TradeSide.Maker,
-                        TransferType.Trade,
-                    ),
+                transferFromAsync.getCall(0).calledWith(
+                    makerTokenAddress, makerAddress, takerAddress, bigNumberMatch(fillableAmount),
+                    TradeSide.Maker, TransferType.Trade,
+                ),
             ).to.be.true();
             expect(
-                transferFromAsync
-                    .getCall(1)
-                    .calledWith(
-                        takerTokenAddress,
-                        takerAddress,
-                        makerAddress,
-                        bigNumberMatch(fillableAmount),
-                        TradeSide.Taker,
-                        TransferType.Trade,
-                    ),
+                transferFromAsync.getCall(1).calledWith(
+                    takerTokenAddress, takerAddress, makerAddress, bigNumberMatch(fillableAmount),
+                    TradeSide.Taker, TransferType.Trade,
+                ),
             ).to.be.true();
             expect(
-                transferFromAsync
-                    .getCall(2)
-                    .calledWith(
-                        zrxTokenAddress,
-                        makerAddress,
-                        feeRecipient,
-                        bigNumberMatch(makerFee),
-                        TradeSide.Maker,
-                        TransferType.Fee,
-                    ),
+                transferFromAsync.getCall(2).calledWith(
+                    zrxTokenAddress, makerAddress, feeRecipient, bigNumberMatch(makerFee),
+                    TradeSide.Maker, TransferType.Fee,
+                ),
             ).to.be.true();
             expect(
-                transferFromAsync
-                    .getCall(3)
-                    .calledWith(
-                        zrxTokenAddress,
-                        takerAddress,
-                        feeRecipient,
-                        bigNumberMatch(takerFee),
-                        TradeSide.Taker,
-                        TransferType.Fee,
-                    ),
+                transferFromAsync.getCall(3).calledWith(
+                    zrxTokenAddress, takerAddress, feeRecipient, bigNumberMatch(takerFee),
+                    TradeSide.Taker, TransferType.Fee,
+                ),
             ).to.be.true();
         });
         it('should correctly round the fillMakerTokenAmount', async () => {
             const makerTokenAmount = new BigNumber(3);
             const takerTokenAmount = new BigNumber(1);
             const signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                makerTokenAmount,
-                takerTokenAmount,
+                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, makerTokenAmount, takerTokenAmount,
             );
-            await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
-                exchangeTransferSimulator,
-                signedOrder,
-                takerTokenAmount,
-                takerAddress,
-                zrxTokenAddress,
+            await orderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+                exchangeTransferSimulator, signedOrder, takerTokenAmount, takerAddress, zrxTokenAddress,
             );
             expect(transferFromAsync.callCount).to.be.equal(4);
             const makerFillAmount = transferFromAsync.getCall(0).args[3];
@@ -444,22 +308,12 @@ describe('OrderValidation', () => {
             const makerFee = new BigNumber(2);
             const takerFee = new BigNumber(4);
             const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerFee,
-                takerFee,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
-                ZeroEx.NULL_ADDRESS,
+                makerTokenAddress, takerTokenAddress, makerFee, takerFee, makerAddress, takerAddress,
+                fillableAmount, ZeroEx.NULL_ADDRESS,
             );
             const fillTakerTokenAmount = fillableAmount.div(2).round(0);
-            await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
-                exchangeTransferSimulator,
-                signedOrder,
-                fillTakerTokenAmount,
-                takerAddress,
-                zrxTokenAddress,
+            await orderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+                exchangeTransferSimulator, signedOrder, fillTakerTokenAmount, takerAddress, zrxTokenAddress,
             );
             const makerPartialFee = makerFee.div(2);
             const takerPartialFee = takerFee.div(2);

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

@@ -1,234 +0,0 @@
-import { ECSignature, SignedOrder } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
-import * as chai from 'chai';
-import 'mocha';
-
-import { ZeroEx } from '../src/0x';
-import { RemainingFillableCalculator } from '../src/order_watcher/remaining_fillable_calculator';
-
-import { chaiSetup } from './utils/chai_setup';
-
-chaiSetup.configure();
-const expect = chai.expect;
-
-describe('RemainingFillableCalculator', () => {
-    let calculator: RemainingFillableCalculator;
-    let signedOrder: SignedOrder;
-    let transferrableMakerTokenAmount: BigNumber;
-    let transferrableMakerFeeTokenAmount: BigNumber;
-    let remainingMakerTokenAmount: BigNumber;
-    let makerAmount: BigNumber;
-    let takerAmount: BigNumber;
-    let makerFeeAmount: BigNumber;
-    let isMakerTokenZRX: boolean;
-    const makerToken: string = '0x1';
-    const takerToken: string = '0x2';
-    const decimals: number = 4;
-    const zero: BigNumber = new BigNumber(0);
-    const zeroAddress = '0x0';
-    const signature: ECSignature = { v: 27, r: '', s: '' };
-    beforeEach(async () => {
-        [makerAmount, takerAmount, makerFeeAmount] = [
-            ZeroEx.toBaseUnitAmount(new BigNumber(50), decimals),
-            ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals),
-            ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals),
-        ];
-        [transferrableMakerTokenAmount, transferrableMakerFeeTokenAmount] = [
-            ZeroEx.toBaseUnitAmount(new BigNumber(50), decimals),
-            ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals),
-        ];
-    });
-    function buildSignedOrder(): SignedOrder {
-        return {
-            ecSignature: signature,
-            exchangeContractAddress: zeroAddress,
-            feeRecipient: zeroAddress,
-            maker: zeroAddress,
-            taker: zeroAddress,
-            makerFee: makerFeeAmount,
-            takerFee: zero,
-            makerTokenAmount: makerAmount,
-            takerTokenAmount: takerAmount,
-            makerTokenAddress: makerToken,
-            takerTokenAddress: takerToken,
-            salt: zero,
-            expirationUnixTimestampSec: zero,
-        };
-    }
-    describe('Maker token is NOT ZRX', () => {
-        before(async () => {
-            isMakerTokenZRX = false;
-        });
-        it('calculates the correct amount when unfilled and funds available', () => {
-            signedOrder = buildSignedOrder();
-            remainingMakerTokenAmount = signedOrder.makerTokenAmount;
-            calculator = new RemainingFillableCalculator(
-                signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
-                transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
-            );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
-        });
-        it('calculates the correct amount when partially filled and funds available', () => {
-            signedOrder = buildSignedOrder();
-            remainingMakerTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals);
-            calculator = new RemainingFillableCalculator(
-                signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
-                transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
-            );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
-        });
-        it('calculates the amount to be 0 when all fee funds are transferred', () => {
-            signedOrder = buildSignedOrder();
-            transferrableMakerFeeTokenAmount = zero;
-            remainingMakerTokenAmount = signedOrder.makerTokenAmount;
-            calculator = new RemainingFillableCalculator(
-                signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
-                transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
-            );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(zero);
-        });
-        it('calculates the correct amount when balance is less than remaining fillable', () => {
-            signedOrder = buildSignedOrder();
-            const partiallyFilledAmount = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-            remainingMakerTokenAmount = signedOrder.makerTokenAmount.minus(partiallyFilledAmount);
-            transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(partiallyFilledAmount);
-            calculator = new RemainingFillableCalculator(
-                signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
-                transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
-            );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(transferrableMakerTokenAmount);
-        });
-        describe('Order to Fee Ratio is < 1', () => {
-            beforeEach(async () => {
-                [makerAmount, takerAmount, makerFeeAmount] = [
-                    ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals),
-                    ZeroEx.toBaseUnitAmount(new BigNumber(6), decimals),
-                    ZeroEx.toBaseUnitAmount(new BigNumber(6), decimals),
-                ];
-            });
-            it('calculates the correct amount when funds unavailable', () => {
-                signedOrder = buildSignedOrder();
-                remainingMakerTokenAmount = signedOrder.makerTokenAmount;
-                const transferredAmount = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-                transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(transferredAmount);
-                calculator = new RemainingFillableCalculator(
-                    signedOrder,
-                    isMakerTokenZRX,
-                    transferrableMakerTokenAmount,
-                    transferrableMakerFeeTokenAmount,
-                    remainingMakerTokenAmount,
-                );
-                expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(transferrableMakerTokenAmount);
-            });
-        });
-        describe('Ratio is not evenly divisble', () => {
-            beforeEach(async () => {
-                [makerAmount, takerAmount, makerFeeAmount] = [
-                    ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals),
-                    ZeroEx.toBaseUnitAmount(new BigNumber(7), decimals),
-                    ZeroEx.toBaseUnitAmount(new BigNumber(7), decimals),
-                ];
-            });
-            it('calculates the correct amount when funds unavailable', () => {
-                signedOrder = buildSignedOrder();
-                remainingMakerTokenAmount = signedOrder.makerTokenAmount;
-                const transferredAmount = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-                transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(transferredAmount);
-                calculator = new RemainingFillableCalculator(
-                    signedOrder,
-                    isMakerTokenZRX,
-                    transferrableMakerTokenAmount,
-                    transferrableMakerFeeTokenAmount,
-                    remainingMakerTokenAmount,
-                );
-                const calculatedFillableAmount = calculator.computeRemainingMakerFillable();
-                expect(calculatedFillableAmount.lessThanOrEqualTo(transferrableMakerTokenAmount)).to.be.true();
-                expect(calculatedFillableAmount).to.be.bignumber.greaterThan(new BigNumber(0));
-                const orderToFeeRatio = signedOrder.makerTokenAmount.dividedBy(signedOrder.makerFee);
-                const calculatedFeeAmount = calculatedFillableAmount.dividedBy(orderToFeeRatio);
-                expect(calculatedFeeAmount).to.be.bignumber.lessThan(transferrableMakerFeeTokenAmount);
-            });
-        });
-    });
-    describe('Maker Token is ZRX', () => {
-        before(async () => {
-            isMakerTokenZRX = true;
-        });
-        it('calculates the correct amount when unfilled and funds available', () => {
-            signedOrder = buildSignedOrder();
-            transferrableMakerTokenAmount = makerAmount.plus(makerFeeAmount);
-            transferrableMakerFeeTokenAmount = transferrableMakerTokenAmount;
-            remainingMakerTokenAmount = signedOrder.makerTokenAmount;
-            calculator = new RemainingFillableCalculator(
-                signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
-                transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
-            );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
-        });
-        it('calculates the correct amount when partially filled and funds available', () => {
-            signedOrder = buildSignedOrder();
-            remainingMakerTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals);
-            calculator = new RemainingFillableCalculator(
-                signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
-                transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
-            );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
-        });
-        it('calculates the amount to be 0 when all fee funds are transferred', () => {
-            signedOrder = buildSignedOrder();
-            transferrableMakerTokenAmount = zero;
-            transferrableMakerFeeTokenAmount = zero;
-            remainingMakerTokenAmount = signedOrder.makerTokenAmount;
-            calculator = new RemainingFillableCalculator(
-                signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
-                transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
-            );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(zero);
-        });
-        it('calculates the correct amount when balance is less than remaining fillable', () => {
-            signedOrder = buildSignedOrder();
-            const partiallyFilledAmount = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-            remainingMakerTokenAmount = signedOrder.makerTokenAmount.minus(partiallyFilledAmount);
-            transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(partiallyFilledAmount);
-            transferrableMakerFeeTokenAmount = transferrableMakerTokenAmount;
-
-            const orderToFeeRatio = signedOrder.makerTokenAmount.dividedToIntegerBy(signedOrder.makerFee);
-            const expectedFillableAmount = new BigNumber(450980);
-            calculator = new RemainingFillableCalculator(
-                signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
-                transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
-            );
-            const calculatedFillableAmount = calculator.computeRemainingMakerFillable();
-            const numberOfFillsInRatio = calculatedFillableAmount.dividedToIntegerBy(orderToFeeRatio);
-            const calculatedFillableAmountPlusFees = calculatedFillableAmount.plus(numberOfFillsInRatio);
-            expect(calculatedFillableAmountPlusFees).to.be.bignumber.lessThan(transferrableMakerTokenAmount);
-            expect(calculatedFillableAmountPlusFees).to.be.bignumber.lessThan(remainingMakerTokenAmount);
-            expect(calculatedFillableAmount).to.be.bignumber.equal(expectedFillableAmount);
-            expect(numberOfFillsInRatio.decimalPlaces()).to.be.equal(0);
-        });
-    });
-});

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

@@ -1,34 +1,42 @@
-import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
-import { BigNumber } from '@0xproject/utils';
-import * as _ from 'lodash';
 import 'mocha';
+import * as _ from 'lodash';
+import * as chai from 'chai';
 import * as Sinon from 'sinon';
+import {chaiSetup} from './utils/chai_setup';
 import * as Web3 from 'web3';
-
-import { ApprovalContractEventArgs, DecodedLogEvent, Token, TokenEvents, ZeroEx } from '../src';
-import { DoneCallback } from '../src/types';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
-import { assertNodeCallbackError } from './utils/report_callback_errors';
-import { web3, web3Wrapper } from './utils/web3_wrapper';
+import BigNumber from 'bignumber.js';
+import promisify = require('es6-promisify');
+import {web3Factory} from './utils/web3_factory';
+import {
+    ZeroEx,
+    ZeroExError,
+    Token,
+    ApprovalContractEventArgs,
+    TokenEvents,
+    DecodedLogEvent,
+} from '../src';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
+import {TokenUtils} from './utils/token_utils';
+import {DoneCallback, BlockParamLiteral} from '../src/types';
 
 chaiSetup.configure();
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle();
 
 describe('SubscriptionTest', () => {
+    let web3: Web3;
     let zeroEx: ZeroEx;
     let userAddresses: string[];
     let tokens: Token[];
+    let tokenUtils: TokenUtils;
     let coinbase: string;
     let addressWithoutFunds: string;
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
     before(async () => {
-        zeroEx = new ZeroEx(web3.currentProvider, config);
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider);
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        tokenUtils = new TokenUtils(tokens);
         coinbase = userAddresses[0];
         addressWithoutFunds = userAddresses[1];
     });
@@ -40,7 +48,9 @@ describe('SubscriptionTest', () => {
     });
     describe('#subscribe', () => {
         const indexFilterValues = {};
+        const shouldThrowOnInsufficientBalanceOrAllowance = true;
         let tokenAddress: string;
+        const transferAmount = new BigNumber(42);
         const allowanceAmount = new BigNumber(42);
         let stubs: Sinon.SinonStub[] = [];
         before(() => {
@@ -52,32 +62,34 @@ describe('SubscriptionTest', () => {
             _.each(stubs, s => s.restore());
             stubs = [];
         });
-        it('Should receive the Error when an error occurs while fetching the block', (done: DoneCallback) => {
+        it('Should receive the Error when an error occurs', (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);
+                const callback = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                    expect(err).to.not.be.null();
+                    expect(logEvent).to.be.undefined();
+                    done();
+                };
+                stubs = [
+                  Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync')
+                   .throws('JSON RPC error'),
+                ];
+                zeroEx.token.subscribe(
+                    tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
                 await zeroEx.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);
-            })().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'))];
+                const callback = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => _.noop;
+                zeroEx.token.subscribe(
+                    tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
+                stubs = [
+                  Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync')
+                   .throws('JSON RPC error'),
+                ];
                 zeroEx.token.unsubscribeAll();
                 done();
             })().catch(done);
-        });
+         });
     });
 });

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

@@ -1,37 +1,32 @@
-import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
-import { schemas, SchemaValidator } from '@0xproject/json-schemas';
-import * as chai from 'chai';
 import * as _ from 'lodash';
 import 'mocha';
-
-import { Token, ZeroEx } from '../src';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
-import { web3, web3Wrapper } from './utils/web3_wrapper';
+import * as chai from 'chai';
+import {SchemaValidator, schemas} from '@0xproject/json-schemas';
+import {chaiSetup} from './utils/chai_setup';
+import {web3Factory} from './utils/web3_factory';
+import {ZeroEx, Token} from '../src';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+const blockchainLifecycle = new BlockchainLifecycle();
 
 const TOKEN_REGISTRY_SIZE_AFTER_MIGRATION = 7;
 
 describe('TokenRegistryWrapper', () => {
     let zeroEx: ZeroEx;
     let tokens: Token[];
-    const tokenAddressBySymbol: { [symbol: string]: string } = {};
-    const tokenAddressByName: { [symbol: string]: string } = {};
-    const tokenBySymbol: { [symbol: string]: Token } = {};
-    const tokenByName: { [symbol: string]: Token } = {};
+    const tokenAddressBySymbol: {[symbol: string]: string} = {};
+    const tokenAddressByName: {[symbol: string]: string} = {};
+    const tokenBySymbol: {[symbol: string]: Token} = {};
+    const tokenByName: {[symbol: string]: Token} = {};
     const registeredSymbol = 'ZRX';
     const registeredName = '0x Protocol Token';
     const unregisteredSymbol = 'MAL';
     const unregisteredName = 'Malicious Token';
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
     before(async () => {
-        zeroEx = new ZeroEx(web3.currentProvider, config);
+        const web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider);
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
         _.map(tokens, token => {
             tokenAddressBySymbol[token.symbol] = token.address;

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

@@ -1,22 +1,17 @@
-import { web3Factory } from '@0xproject/dev-utils';
 import * as chai from 'chai';
-
-import { ZeroEx } from '../src';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
+import {chaiSetup} from './utils/chai_setup';
+import {web3Factory} from './utils/web3_factory';
+import {ZeroEx} from '../src';
+import {TokenTransferProxyWrapper} from '../src/contract_wrappers/token_transfer_proxy_wrapper';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const web3 = web3Factory.create();
 
 describe('TokenTransferProxyWrapper', () => {
     let zeroEx: ZeroEx;
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
     before(async () => {
-        zeroEx = new ZeroEx(web3.currentProvider, config);
+        const web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider);
     });
     describe('#isAuthorizedAsync', () => {
         it('should return false if the address is not authorized', async () => {

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

@@ -1,45 +1,43 @@
-import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
-import { BigNumber } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import * as chai from 'chai';
 import 'mocha';
+import * as chai from 'chai';
+import {chaiSetup} from './utils/chai_setup';
 import * as Web3 from 'web3';
-
+import BigNumber from 'bignumber.js';
+import promisify = require('es6-promisify');
+import {web3Factory} from './utils/web3_factory';
 import {
-    ApprovalContractEventArgs,
-    BlockParamLiteral,
-    BlockRange,
-    DecodedLogEvent,
-    Token,
-    TokenEvents,
-    TransferContractEventArgs,
     ZeroEx,
     ZeroExError,
+    Token,
+    SubscriptionOpts,
+    TokenEvents,
+    ContractEvent,
+    TransferContractEventArgs,
+    ApprovalContractEventArgs,
+    TokenContractEventArgs,
+    LogWithDecodedArgs,
+    LogEvent,
+    DecodedLogEvent,
 } 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 { web3, web3Wrapper } from './utils/web3_wrapper';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
+import {TokenUtils} from './utils/token_utils';
+import {DoneCallback, BlockParamLiteral} from '../src/types';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+const blockchainLifecycle = new BlockchainLifecycle();
 
 describe('TokenWrapper', () => {
+    let web3: Web3;
     let zeroEx: ZeroEx;
     let userAddresses: string[];
     let tokens: Token[];
     let tokenUtils: TokenUtils;
     let coinbase: string;
     let addressWithoutFunds: string;
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
     before(async () => {
-        zeroEx = new ZeroEx(web3.currentProvider, config);
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider);
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
         tokenUtils = new TokenUtils(tokens);
@@ -64,24 +62,25 @@ describe('TokenWrapper', () => {
             const toAddress = addressWithoutFunds;
             const preBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
             expect(preBalance).to.be.bignumber.equal(0);
-            await zeroEx.token.transferAsync(token.address, fromAddress, toAddress, transferAmount);
+            const txHash = await zeroEx.token.transferAsync(token.address, fromAddress, toAddress, transferAmount);
+            const receipt = await zeroEx.awaitTransactionMinedAsync(txHash);
             const postBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
             return expect(postBalance).to.be.bignumber.equal(transferAmount);
         });
         it('should fail to transfer tokens if fromAddress has an insufficient balance', async () => {
             const fromAddress = addressWithoutFunds;
             const toAddress = coinbase;
-            return expect(
-                zeroEx.token.transferAsync(token.address, fromAddress, toAddress, transferAmount),
-            ).to.be.rejectedWith(ZeroExError.InsufficientBalanceForTransfer);
+            return expect(zeroEx.token.transferAsync(
+                token.address, fromAddress, toAddress, transferAmount,
+            )).to.be.rejectedWith(ZeroExError.InsufficientBalanceForTransfer);
         });
         it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
             const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
             const fromAddress = coinbase;
             const toAddress = coinbase;
-            return expect(
-                zeroEx.token.transferAsync(nonExistentTokenAddress, fromAddress, toAddress, transferAmount),
-            ).to.be.rejectedWith(ZeroExError.TokenContractDoesNotExist);
+            return expect(zeroEx.token.transferAsync(
+                nonExistentTokenAddress, fromAddress, toAddress, transferAmount,
+            )).to.be.rejectedWith(ZeroExError.ContractDoesNotExist);
         });
     });
     describe('#transferFromAsync', () => {
@@ -100,22 +99,24 @@ describe('TokenWrapper', () => {
             const fromAddressBalance = await zeroEx.token.getBalanceAsync(token.address, fromAddress);
             expect(fromAddressBalance).to.be.bignumber.greaterThan(transferAmount);
 
-            const fromAddressAllowance = await zeroEx.token.getAllowanceAsync(token.address, fromAddress, toAddress);
+            const fromAddressAllowance = await zeroEx.token.getAllowanceAsync(token.address, fromAddress,
+                                                                              toAddress);
             expect(fromAddressAllowance).to.be.bignumber.equal(0);
 
-            return expect(
-                zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount),
-            ).to.be.rejectedWith(ZeroExError.InsufficientAllowanceForTransfer);
+            return expect(zeroEx.token.transferFromAsync(
+                token.address, fromAddress, toAddress, senderAddress, transferAmount,
+            )).to.be.rejectedWith(ZeroExError.InsufficientAllowanceForTransfer);
         });
-        it('[regression] should fail to transfer tokens if set allowance for toAddress instead of senderAddress', async () => {
+        it('[regression] should fail to transfer tokens if set allowance for toAddress instead of senderAddress',
+            async () => {
             const fromAddress = coinbase;
             const transferAmount = new BigNumber(42);
 
             await zeroEx.token.setAllowanceAsync(token.address, fromAddress, toAddress, transferAmount);
 
-            return expect(
-                zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount),
-            ).to.be.rejectedWith(ZeroExError.InsufficientAllowanceForTransfer);
+            return expect(zeroEx.token.transferFromAsync(
+                token.address, fromAddress, toAddress, senderAddress, transferAmount,
+            )).to.be.rejectedWith(ZeroExError.InsufficientAllowanceForTransfer);
         });
         it('should fail to transfer tokens if fromAddress has insufficient balance', async () => {
             const fromAddress = addressWithoutFunds;
@@ -125,16 +126,13 @@ describe('TokenWrapper', () => {
             expect(fromAddressBalance).to.be.bignumber.equal(0);
 
             await zeroEx.token.setAllowanceAsync(token.address, fromAddress, senderAddress, transferAmount);
-            const fromAddressAllowance = await zeroEx.token.getAllowanceAsync(
-                token.address,
-                fromAddress,
-                senderAddress,
-            );
+            const fromAddressAllowance = await zeroEx.token.getAllowanceAsync(token.address, fromAddress,
+                                                                              senderAddress);
             expect(fromAddressAllowance).to.be.bignumber.equal(transferAmount);
 
-            return expect(
-                zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount),
-            ).to.be.rejectedWith(ZeroExError.InsufficientBalanceForTransfer);
+            return expect(zeroEx.token.transferFromAsync(
+                token.address, fromAddress, toAddress, senderAddress, transferAmount,
+            )).to.be.rejectedWith(ZeroExError.InsufficientBalanceForTransfer);
         });
         it('should successfully transfer tokens', async () => {
             const fromAddress = coinbase;
@@ -145,22 +143,17 @@ describe('TokenWrapper', () => {
             const transferAmount = new BigNumber(42);
             await zeroEx.token.setAllowanceAsync(token.address, fromAddress, senderAddress, transferAmount);
 
-            await zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount);
+            await zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress,
+                                                 transferAmount);
             const postBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
             return expect(postBalance).to.be.bignumber.equal(transferAmount);
         });
         it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
             const fromAddress = coinbase;
             const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
-            return expect(
-                zeroEx.token.transferFromAsync(
-                    nonExistentTokenAddress,
-                    fromAddress,
-                    toAddress,
-                    senderAddress,
-                    new BigNumber(42),
-                ),
-            ).to.be.rejectedWith(ZeroExError.TokenContractDoesNotExist);
+            return expect(zeroEx.token.transferFromAsync(
+                nonExistentTokenAddress, fromAddress, toAddress, senderAddress, new BigNumber(42),
+            )).to.be.rejectedWith(ZeroExError.ContractDoesNotExist);
         });
     });
     describe('#getBalanceAsync', () => {
@@ -175,9 +168,8 @@ describe('TokenWrapper', () => {
             it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
                 const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
                 const ownerAddress = coinbase;
-                return expect(zeroEx.token.getBalanceAsync(nonExistentTokenAddress, ownerAddress)).to.be.rejectedWith(
-                    ZeroExError.TokenContractDoesNotExist,
-                );
+                return expect(zeroEx.token.getBalanceAsync(nonExistentTokenAddress, ownerAddress))
+                    .to.be.rejectedWith(ZeroExError.ContractDoesNotExist);
             });
             it('should return a balance of 0 for a non-existent owner address', async () => {
                 const token = tokens[0];
@@ -191,29 +183,26 @@ describe('TokenWrapper', () => {
             let zeroExWithoutAccounts: ZeroEx;
             before(async () => {
                 const hasAddresses = false;
-                const web3WithoutAccounts = web3Factory.create({ hasAddresses });
-                zeroExWithoutAccounts = new ZeroEx(web3WithoutAccounts.currentProvider, config);
+                const web3WithoutAccounts = web3Factory.create(hasAddresses);
+                zeroExWithoutAccounts = new ZeroEx(web3WithoutAccounts.currentProvider);
             });
             it('should return balance even when called with Web3 provider instance without addresses', async () => {
-                const token = tokens[0];
-                const ownerAddress = coinbase;
-                const balance = await zeroExWithoutAccounts.token.getBalanceAsync(token.address, ownerAddress);
-                const expectedBalance = new BigNumber('1000000000000000000000000000');
-                return expect(balance).to.be.bignumber.equal(expectedBalance);
+                    const token = tokens[0];
+                    const ownerAddress = coinbase;
+                    const balance = await zeroExWithoutAccounts.token.getBalanceAsync(token.address, ownerAddress);
+                    const expectedBalance = new BigNumber('1000000000000000000000000000');
+                    return expect(balance).to.be.bignumber.equal(expectedBalance);
             });
         });
     });
     describe('#setAllowanceAsync', () => {
-        it("should set the spender's allowance", async () => {
+        it('should set the spender\'s allowance', async () => {
             const token = tokens[0];
             const ownerAddress = coinbase;
             const spenderAddress = addressWithoutFunds;
 
-            const allowanceBeforeSet = await zeroEx.token.getAllowanceAsync(
-                token.address,
-                ownerAddress,
-                spenderAddress,
-            );
+            const allowanceBeforeSet = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress,
+                                                                            spenderAddress);
             const expectedAllowanceBeforeAllowanceSet = new BigNumber(0);
             expect(allowanceBeforeSet).to.be.bignumber.equal(expectedAllowanceBeforeAllowanceSet);
 
@@ -226,7 +215,7 @@ describe('TokenWrapper', () => {
         });
     });
     describe('#setUnlimitedAllowanceAsync', () => {
-        it("should set the unlimited spender's allowance", async () => {
+        it('should set the unlimited spender\'s allowance', async () => {
             const token = tokens[0];
             const ownerAddress = coinbase;
             const spenderAddress = addressWithoutFunds;
@@ -242,30 +231,18 @@ describe('TokenWrapper', () => {
             await zeroEx.token.setAllowanceAsync(zrx.address, coinbase, userWithNormalAllowance, transferAmount);
             await zeroEx.token.setUnlimitedAllowanceAsync(zrx.address, coinbase, userWithUnlimitedAllowance);
 
-            const initBalanceWithNormalAllowance = await web3Wrapper.getBalanceInWeiAsync(userWithNormalAllowance);
-            const initBalanceWithUnlimitedAllowance = await web3Wrapper.getBalanceInWeiAsync(
-                userWithUnlimitedAllowance,
-            );
+            const initBalanceWithNormalAllowance = await promisify(web3.eth.getBalance)(userWithNormalAllowance);
+            const initBalanceWithUnlimitedAllowance = await promisify(web3.eth.getBalance)(userWithUnlimitedAllowance);
 
             await zeroEx.token.transferFromAsync(
-                zrx.address,
-                coinbase,
-                userWithNormalAllowance,
-                userWithNormalAllowance,
-                transferAmount,
+                zrx.address, coinbase, userWithNormalAllowance, userWithNormalAllowance, transferAmount,
             );
             await zeroEx.token.transferFromAsync(
-                zrx.address,
-                coinbase,
-                userWithUnlimitedAllowance,
-                userWithUnlimitedAllowance,
-                transferAmount,
+                zrx.address, coinbase, userWithUnlimitedAllowance, userWithUnlimitedAllowance, transferAmount,
             );
 
-            const finalBalanceWithNormalAllowance = await web3Wrapper.getBalanceInWeiAsync(userWithNormalAllowance);
-            const finalBalanceWithUnlimitedAllowance = await web3Wrapper.getBalanceInWeiAsync(
-                userWithUnlimitedAllowance,
-            );
+            const finalBalanceWithNormalAllowance = await promisify(web3.eth.getBalance)(userWithNormalAllowance);
+            const finalBalanceWithUnlimitedAllowance = await promisify(web3.eth.getBalance)(userWithUnlimitedAllowance);
 
             const normalGasCost = initBalanceWithNormalAllowance.minus(finalBalanceWithNormalAllowance);
             const unlimitedGasCost = initBalanceWithUnlimitedAllowance.minus(finalBalanceWithUnlimitedAllowance);
@@ -303,8 +280,8 @@ describe('TokenWrapper', () => {
             let zeroExWithoutAccounts: ZeroEx;
             before(async () => {
                 const hasAddresses = false;
-                const web3WithoutAccounts = web3Factory.create({ hasAddresses });
-                zeroExWithoutAccounts = new ZeroEx(web3WithoutAccounts.currentProvider, config);
+                const web3WithoutAccounts = web3Factory.create(hasAddresses);
+                zeroExWithoutAccounts = new ZeroEx(web3WithoutAccounts.currentProvider);
             });
             it('should get the proxy allowance', async () => {
                 const token = tokens[0];
@@ -315,9 +292,7 @@ describe('TokenWrapper', () => {
                 await zeroEx.token.setAllowanceAsync(token.address, ownerAddress, spenderAddress, amountInBaseUnits);
 
                 const allowance = await zeroExWithoutAccounts.token.getAllowanceAsync(
-                    token.address,
-                    ownerAddress,
-                    spenderAddress,
+                    token.address, ownerAddress, spenderAddress,
                 );
                 const expectedAllowance = amountInBaseUnits;
                 return expect(allowance).to.be.bignumber.equal(expectedAllowance);
@@ -366,6 +341,7 @@ describe('TokenWrapper', () => {
     });
     describe('#subscribe', () => {
         const indexFilterValues = {};
+        const shouldThrowOnInsufficientBalanceOrAllowance = true;
         let tokenAddress: string;
         const transferAmount = new BigNumber(42);
         const allowanceAmount = new BigNumber(42);
@@ -383,66 +359,63 @@ describe('TokenWrapper', () => {
         // 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)(
-                    (logEvent: DecodedLogEvent<TransferContractEventArgs>) => {
-                        expect(logEvent.isRemoved).to.be.false();
-                        expect(logEvent.log.logIndex).to.be.equal(0);
-                        expect(logEvent.log.transactionIndex).to.be.equal(0);
-                        expect(logEvent.log.blockNumber).to.be.a('number');
-                        const args = logEvent.log.args;
-                        expect(args._from).to.be.equal(coinbase);
-                        expect(args._to).to.be.equal(addressWithoutFunds);
-                        expect(args._value).to.be.bignumber.equal(transferAmount);
-                    },
-                );
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callback);
+                const callback = (err: Error, logEvent: DecodedLogEvent<TransferContractEventArgs>) => {
+                    expect(logEvent).to.not.be.undefined();
+                    expect(logEvent.logIndex).to.be.equal(0);
+                    expect(logEvent.transactionIndex).to.be.equal(0);
+                    expect(logEvent.blockNumber).to.be.a('number');
+                    const args = logEvent.args;
+                    expect(args._from).to.be.equal(coinbase);
+                    expect(args._to).to.be.equal(addressWithoutFunds);
+                    expect(args._value).to.be.bignumber.equal(transferAmount);
+                    done();
+                };
+                zeroEx.token.subscribe(
+                    tokenAddress, TokenEvents.Transfer, indexFilterValues, callback);
                 await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
             })().catch(done);
         });
         it('Should receive the Approval event when allowance is being set', (done: DoneCallback) => {
             (async () => {
-                const callback = reportNodeCallbackErrors(done)(
-                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-                        expect(logEvent).to.not.be.undefined();
-                        expect(logEvent.isRemoved).to.be.false();
-                        const args = logEvent.log.args;
-                        expect(args._owner).to.be.equal(coinbase);
-                        expect(args._spender).to.be.equal(addressWithoutFunds);
-                        expect(args._value).to.be.bignumber.equal(allowanceAmount);
-                    },
-                );
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
+                const callback = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                    expect(logEvent).to.not.be.undefined();
+                    const args = logEvent.args;
+                    expect(args._owner).to.be.equal(coinbase);
+                    expect(args._spender).to.be.equal(addressWithoutFunds);
+                    expect(args._value).to.be.bignumber.equal(allowanceAmount);
+                    done();
+                };
+                zeroEx.token.subscribe(
+                    tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
                 await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
             })().catch(done);
         });
-        it('Outstanding subscriptions are cancelled when zeroEx.setProvider called', (done: DoneCallback) => {
+        it('Outstanding subscriptions are cancelled when zeroEx.setProviderAsync called', (done: DoneCallback) => {
             (async () => {
-                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
-                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-                        done(new Error('Expected this subscription to have been cancelled'));
-                    },
+                const callbackNeverToBeCalled = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                    done(new Error('Expected this subscription to have been cancelled'));
+                };
+                zeroEx.token.subscribe(
+                    tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackNeverToBeCalled,
                 );
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackNeverToBeCalled);
-                const callbackToBeCalled = reportNodeCallbackErrors(done)();
+                const callbackToBeCalled = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                    done();
+                };
                 const newProvider = web3Factory.getRpcProvider();
-                zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackToBeCalled);
+                await zeroEx.setProviderAsync(newProvider);
+                zeroEx.token.subscribe(
+                    tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackToBeCalled,
+                );
                 await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
             })().catch(done);
         });
         it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
             (async () => {
-                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
-                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-                        done(new Error('Expected this subscription to have been cancelled'));
-                    },
-                );
+                const callbackNeverToBeCalled = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                    done(new Error('Expected this subscription to have been cancelled'));
+                };
                 const subscriptionToken = zeroEx.token.subscribe(
-                    tokenAddress,
-                    TokenEvents.Transfer,
-                    indexFilterValues,
-                    callbackNeverToBeCalled,
-                );
+                    tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackNeverToBeCalled);
                 zeroEx.token.unsubscribe(subscriptionToken);
                 await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
                 done();
@@ -452,15 +425,15 @@ describe('TokenWrapper', () => {
     describe('#getLogsAsync', () => {
         let tokenAddress: string;
         let tokenTransferProxyAddress: string;
-        const blockRange: BlockRange = {
-            fromBlock: 0,
+        const subscriptionOpts: SubscriptionOpts = {
+            fromBlock: BlockParamLiteral.Earliest,
             toBlock: BlockParamLiteral.Latest,
         };
         let txHash: string;
-        before(() => {
+        before(async () => {
             const token = tokens[0];
             tokenAddress = token.address;
-            tokenTransferProxyAddress = zeroEx.proxy.getContractAddress();
+            tokenTransferProxyAddress = await zeroEx.proxy.getContractAddressAsync();
         });
         it('should get logs with decoded args emitted by Approval', async () => {
             txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, coinbase);
@@ -468,10 +441,7 @@ describe('TokenWrapper', () => {
             const eventName = TokenEvents.Approval;
             const indexFilterValues = {};
             const logs = await zeroEx.token.getLogsAsync<ApprovalContractEventArgs>(
-                tokenAddress,
-                eventName,
-                blockRange,
-                indexFilterValues,
+                tokenAddress, eventName, subscriptionOpts, indexFilterValues,
             );
             expect(logs).to.have.length(1);
             const args = logs[0].args;
@@ -486,10 +456,7 @@ describe('TokenWrapper', () => {
             const differentEventName = TokenEvents.Transfer;
             const indexFilterValues = {};
             const logs = await zeroEx.token.getLogsAsync(
-                tokenAddress,
-                differentEventName,
-                blockRange,
-                indexFilterValues,
+                tokenAddress, differentEventName, subscriptionOpts, indexFilterValues,
             );
             expect(logs).to.have.length(0);
         });
@@ -503,10 +470,7 @@ describe('TokenWrapper', () => {
                 _owner: coinbase,
             };
             const logs = await zeroEx.token.getLogsAsync<ApprovalContractEventArgs>(
-                tokenAddress,
-                eventName,
-                blockRange,
-                indexFilterValues,
+                tokenAddress, eventName, subscriptionOpts, indexFilterValues,
             );
             expect(logs).to.have.length(1);
             const args = logs[0].args;
@@ -514,4 +478,3 @@ describe('TokenWrapper', () => {
         });
     });
 });
-// tslint:disable:max-file-line-count

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

@@ -0,0 +1,26 @@
+import {RPC} from './rpc';
+
+export class BlockchainLifecycle {
+    private rpc: RPC;
+    private snapshotIdsStack: number[];
+    constructor() {
+        this.rpc = new RPC();
+        this.snapshotIdsStack = [];
+    }
+    // TODO: In order to run these tests on an actual node, we should check if we are running against
+    // TestRPC, if so, use snapshots, otherwise re-deploy contracts before every test
+    public async startAsync(): Promise<void> {
+        const snapshotId = await this.rpc.takeSnapshotAsync();
+        this.snapshotIdsStack.push(snapshotId);
+    }
+    public async revertAsync(): Promise<void> {
+        const snapshotId = this.snapshotIdsStack.pop() as number;
+        const didRevert = await this.rpc.revertSnapshotAsync(snapshotId);
+        if (!didRevert) {
+            throw new Error(`Snapshot with id #${snapshotId} failed to revert`);
+        }
+    }
+    public async mineABlock(): Promise<void> {
+        await this.rpc.mineBlockAsync();
+    }
+}

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

@@ -1,7 +1,7 @@
 import * as chai from 'chai';
-import chaiAsPromised = require('chai-as-promised');
-import ChaiBigNumber = require('chai-bignumber');
 import * as dirtyChai from 'dirty-chai';
+import ChaiBigNumber = require('chai-bignumber');
+import chaiAsPromised = require('chai-as-promised');
 
 export const chaiSetup = {
     configure() {

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

@@ -1,9 +1,8 @@
 export const constants = {
     NULL_ADDRESS: '0x0000000000000000000000000000000000000000',
-    ROPSTEN_NETWORK_ID: 3,
-    KOVAN_NETWORK_ID: 42,
+    RPC_HOST: 'localhost',
+    RPC_PORT: 8545,
     TESTRPC_NETWORK_ID: 50,
-    KOVAN_RPC_URL: 'https://kovan.infura.io/',
-    ROPSTEN_RPC_URL: 'https://ropsten.infura.io/',
-    ZRX_DECIMALS: 18,
+    KOVAN_RPC_URL: 'https://kovan.infura.io',
+    ROPSTEN_RPC_URL: 'https://ropsten.infura.io',
 };

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

@@ -1,198 +1,114 @@
-import { BigNumber } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
-
-import { SignedOrder, Token, ZeroEx } from '../../src';
-import { artifacts } from '../../src/artifacts';
-import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token';
-import { orderFactory } from '../utils/order_factory';
-
-import { constants } from './constants';
-
-const INITIAL_COINBASE_TOKEN_SUPPLY_IN_UNITS = new BigNumber(100);
+import BigNumber from 'bignumber.js';
+import {ZeroEx, Token, SignedOrder} from '../../src';
+import {orderFactory} from '../utils/order_factory';
+import {constants} from './constants';
 
 export class FillScenarios {
-    private _zeroEx: ZeroEx;
-    private _userAddresses: string[];
-    private _tokens: Token[];
-    private _coinbase: string;
-    private _zrxTokenAddress: string;
-    private _exchangeContractAddress: string;
-    constructor(
-        zeroEx: ZeroEx,
-        userAddresses: string[],
-        tokens: Token[],
-        zrxTokenAddress: string,
-        exchangeContractAddress: string,
-    ) {
-        this._zeroEx = zeroEx;
-        this._userAddresses = userAddresses;
-        this._tokens = tokens;
-        this._coinbase = userAddresses[0];
-        this._zrxTokenAddress = zrxTokenAddress;
-        this._exchangeContractAddress = exchangeContractAddress;
+    private zeroEx: ZeroEx;
+    private userAddresses: string[];
+    private tokens: Token[];
+    private coinbase: string;
+    private zrxTokenAddress: string;
+    private exchangeContractAddress: string;
+    constructor(zeroEx: ZeroEx, userAddresses: string[],
+                tokens: Token[], zrxTokenAddress: string, exchangeContractAddress: string) {
+        this.zeroEx = zeroEx;
+        this.userAddresses = userAddresses;
+        this.tokens = tokens;
+        this.coinbase = userAddresses[0];
+        this.zrxTokenAddress = zrxTokenAddress;
+        this.exchangeContractAddress = exchangeContractAddress;
     }
-    public async initTokenBalancesAsync() {
-        const web3Wrapper = (this._zeroEx as any)._web3Wrapper as Web3Wrapper;
-        for (const token of this._tokens) {
-            if (token.symbol !== 'ZRX' && token.symbol !== 'WETH') {
-                const defaults = {};
-                const dummyToken = new DummyTokenContract(web3Wrapper, artifacts.DummyTokenArtifact.abi, token.address);
-                const tokenSupply = ZeroEx.toBaseUnitAmount(INITIAL_COINBASE_TOKEN_SUPPLY_IN_UNITS, token.decimals);
-                const txHash = await dummyToken.setBalance.sendTransactionAsync(this._coinbase, tokenSupply, {
-                    from: this._coinbase,
-                });
-                await this._zeroEx.awaitTransactionMinedAsync(txHash);
-            }
-        }
-    }
-    public async createFillableSignedOrderAsync(
-        makerTokenAddress: string,
-        takerTokenAddress: string,
-        makerAddress: string,
-        takerAddress: string,
-        fillableAmount: BigNumber,
-        expirationUnixTimestampSec?: BigNumber,
-    ): Promise<SignedOrder> {
+    public async createFillableSignedOrderAsync(makerTokenAddress: string, takerTokenAddress: string,
+                                                makerAddress: string, takerAddress: string,
+                                                fillableAmount: BigNumber,
+                                                expirationUnixTimestampSec?: BigNumber):
+                                           Promise<SignedOrder> {
         return this.createAsymmetricFillableSignedOrderAsync(
-            makerTokenAddress,
-            takerTokenAddress,
-            makerAddress,
-            takerAddress,
-            fillableAmount,
-            fillableAmount,
-            expirationUnixTimestampSec,
+            makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
+            fillableAmount, fillableAmount, expirationUnixTimestampSec,
         );
     }
     public async createFillableSignedOrderWithFeesAsync(
-        makerTokenAddress: string,
-        takerTokenAddress: string,
-        makerFee: BigNumber,
-        takerFee: BigNumber,
-        makerAddress: string,
-        takerAddress: string,
+        makerTokenAddress: string, takerTokenAddress: string,
+        makerFee: BigNumber, takerFee: BigNumber,
+        makerAddress: string, takerAddress: string,
         fillableAmount: BigNumber,
-        feeRecepient: string,
-        expirationUnixTimestampSec?: BigNumber,
+        feeRecepient: string, expirationUnixTimestampSec?: BigNumber,
     ): Promise<SignedOrder> {
-        return this._createAsymmetricFillableSignedOrderWithFeesAsync(
-            makerTokenAddress,
-            takerTokenAddress,
-            makerFee,
-            takerFee,
-            makerAddress,
-            takerAddress,
-            fillableAmount,
-            fillableAmount,
-            feeRecepient,
-            expirationUnixTimestampSec,
+        return this.createAsymmetricFillableSignedOrderWithFeesAsync(
+            makerTokenAddress, takerTokenAddress, makerFee, takerFee, makerAddress, takerAddress,
+            fillableAmount, fillableAmount, feeRecepient, expirationUnixTimestampSec,
         );
     }
     public async createAsymmetricFillableSignedOrderAsync(
-        makerTokenAddress: string,
-        takerTokenAddress: string,
-        makerAddress: string,
-        takerAddress: string,
-        makerFillableAmount: BigNumber,
-        takerFillableAmount: BigNumber,
-        expirationUnixTimestampSec?: BigNumber,
-    ): Promise<SignedOrder> {
+        makerTokenAddress: string, takerTokenAddress: string, makerAddress: string, takerAddress: string,
+        makerFillableAmount: BigNumber, takerFillableAmount: BigNumber,
+        expirationUnixTimestampSec?: BigNumber): Promise<SignedOrder> {
         const makerFee = new BigNumber(0);
         const takerFee = new BigNumber(0);
         const feeRecepient = constants.NULL_ADDRESS;
-        return this._createAsymmetricFillableSignedOrderWithFeesAsync(
-            makerTokenAddress,
-            takerTokenAddress,
-            makerFee,
-            takerFee,
-            makerAddress,
-            takerAddress,
-            makerFillableAmount,
-            takerFillableAmount,
-            feeRecepient,
-            expirationUnixTimestampSec,
+        return this.createAsymmetricFillableSignedOrderWithFeesAsync(
+            makerTokenAddress, takerTokenAddress, makerFee, takerFee, makerAddress, takerAddress,
+            makerFillableAmount, takerFillableAmount, feeRecepient, expirationUnixTimestampSec,
         );
     }
-    public async createPartiallyFilledSignedOrderAsync(
-        makerTokenAddress: string,
-        takerTokenAddress: string,
-        takerAddress: string,
-        fillableAmount: BigNumber,
-        partialFillAmount: BigNumber,
-    ) {
-        const [makerAddress] = this._userAddresses;
+    public async createPartiallyFilledSignedOrderAsync(makerTokenAddress: string, takerTokenAddress: string,
+                                                       takerAddress: string, fillableAmount: BigNumber,
+                                                       partialFillAmount: BigNumber) {
+        const [makerAddress] = this.userAddresses;
         const signedOrder = await this.createAsymmetricFillableSignedOrderAsync(
-            makerTokenAddress,
-            takerTokenAddress,
-            makerAddress,
-            takerAddress,
-            fillableAmount,
-            fillableAmount,
+            makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
+            fillableAmount, fillableAmount,
         );
         const shouldThrowOnInsufficientBalanceOrAllowance = false;
-        await this._zeroEx.exchange.fillOrderAsync(
-            signedOrder,
-            partialFillAmount,
-            shouldThrowOnInsufficientBalanceOrAllowance,
-            takerAddress,
+        await this.zeroEx.exchange.fillOrderAsync(
+            signedOrder, partialFillAmount, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
         );
         return signedOrder;
     }
-    private async _createAsymmetricFillableSignedOrderWithFeesAsync(
-        makerTokenAddress: string,
-        takerTokenAddress: string,
-        makerFee: BigNumber,
-        takerFee: BigNumber,
-        makerAddress: string,
-        takerAddress: string,
-        makerFillableAmount: BigNumber,
-        takerFillableAmount: BigNumber,
-        feeRecepient: string,
-        expirationUnixTimestampSec?: BigNumber,
-    ): Promise<SignedOrder> {
+    private async createAsymmetricFillableSignedOrderWithFeesAsync(
+        makerTokenAddress: string, takerTokenAddress: string,
+        makerFee: BigNumber, takerFee: BigNumber,
+        makerAddress: string, takerAddress: string,
+        makerFillableAmount: BigNumber, takerFillableAmount: BigNumber,
+        feeRecepient: string, expirationUnixTimestampSec?: BigNumber): Promise<SignedOrder> {
+
         await Promise.all([
-            this._increaseBalanceAndAllowanceAsync(makerTokenAddress, makerAddress, makerFillableAmount),
-            this._increaseBalanceAndAllowanceAsync(takerTokenAddress, takerAddress, takerFillableAmount),
+            this.increaseBalanceAndAllowanceAsync(makerTokenAddress, makerAddress, makerFillableAmount),
+            this.increaseBalanceAndAllowanceAsync(takerTokenAddress, takerAddress, takerFillableAmount),
         ]);
         await Promise.all([
-            this._increaseBalanceAndAllowanceAsync(this._zrxTokenAddress, makerAddress, makerFee),
-            this._increaseBalanceAndAllowanceAsync(this._zrxTokenAddress, takerAddress, takerFee),
+            this.increaseBalanceAndAllowanceAsync(this.zrxTokenAddress, makerAddress, makerFee),
+            this.increaseBalanceAndAllowanceAsync(this.zrxTokenAddress, takerAddress, takerFee),
         ]);
 
-        const signedOrder = await orderFactory.createSignedOrderAsync(
-            this._zeroEx,
-            makerAddress,
-            takerAddress,
-            makerFee,
-            takerFee,
-            makerFillableAmount,
-            makerTokenAddress,
-            takerFillableAmount,
-            takerTokenAddress,
-            this._exchangeContractAddress,
-            feeRecepient,
-            expirationUnixTimestampSec,
-        );
+        const signedOrder = await orderFactory.createSignedOrderAsync(this.zeroEx,
+            makerAddress, takerAddress, makerFee, takerFee,
+            makerFillableAmount, makerTokenAddress, takerFillableAmount, takerTokenAddress,
+            this.exchangeContractAddress, feeRecepient, expirationUnixTimestampSec);
         return signedOrder;
     }
-    private async _increaseBalanceAndAllowanceAsync(
-        tokenAddress: string,
-        address: string,
-        amount: BigNumber,
-    ): Promise<void> {
+    private async increaseBalanceAndAllowanceAsync(
+        tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
         if (amount.isZero() || address === ZeroEx.NULL_ADDRESS) {
             return; // noop
         }
         await Promise.all([
-            this._increaseBalanceAsync(tokenAddress, address, amount),
-            this._increaseAllowanceAsync(tokenAddress, address, amount),
+            this.increaseBalanceAsync(tokenAddress, address, amount),
+            this.increaseAllowanceAsync(tokenAddress, address, amount),
         ]);
     }
-    private async _increaseBalanceAsync(tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
-        await this._zeroEx.token.transferAsync(tokenAddress, this._coinbase, address, amount);
+    private async increaseBalanceAsync(
+        tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
+        await this.zeroEx.token.transferAsync(tokenAddress, this.coinbase, address, amount);
     }
-    private async _increaseAllowanceAsync(tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
-        const oldMakerAllowance = await this._zeroEx.token.getProxyAllowanceAsync(tokenAddress, address);
+    private async increaseAllowanceAsync(
+        tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
+        const oldMakerAllowance = await this.zeroEx.token.getProxyAllowanceAsync(tokenAddress, address);
         const newMakerAllowance = oldMakerAllowance.plus(amount);
-        await this._zeroEx.token.setProxyAllowanceAsync(tokenAddress, address, newMakerAllowance);
+        await this.zeroEx.token.setProxyAllowanceAsync(
+            tokenAddress, address, newMakerAllowance,
+        );
     }
 }

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

@@ -1,9 +1,6 @@
-import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
-
-import { SignedOrder, ZeroEx } from '../../src';
-
-const SHOULD_ADD_PERSONAL_MESSAGE_PREFIX = false;
+import BigNumber from 'bignumber.js';
+import {ZeroEx, SignedOrder} from '../../src';
 
 export const orderFactory = {
     async createSignedOrderAsync(
@@ -18,12 +15,11 @@ export const orderFactory = {
         takerTokenAddress: string,
         exchangeContractAddress: string,
         feeRecipient: string,
-        expirationUnixTimestampSecIfExists?: BigNumber,
-    ): Promise<SignedOrder> {
+        expirationUnixTimestampSec?: BigNumber): Promise<SignedOrder> {
         const defaultExpirationUnixTimestampSec = new BigNumber(2524604400); // Close to infinite
-        const expirationUnixTimestampSec = _.isUndefined(expirationUnixTimestampSecIfExists)
-            ? defaultExpirationUnixTimestampSec
-            : expirationUnixTimestampSecIfExists;
+        expirationUnixTimestampSec = _.isUndefined(expirationUnixTimestampSec) ?
+            defaultExpirationUnixTimestampSec :
+            expirationUnixTimestampSec;
         const order = {
             maker,
             taker,
@@ -39,8 +35,8 @@ export const orderFactory = {
             expirationUnixTimestampSec,
         };
         const orderHash = ZeroEx.getOrderHashHex(order);
-        const ecSignature = await zeroEx.signOrderHashAsync(orderHash, maker, SHOULD_ADD_PERSONAL_MESSAGE_PREFIX);
-        const signedOrder: SignedOrder = _.assign(order, { ecSignature });
+        const ecSignature = await zeroEx.signOrderHashAsync(orderHash, maker);
+        const signedOrder: SignedOrder = _.assign(order, {ecSignature});
         return signedOrder;
     },
 };

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

@@ -1,22 +1,10 @@
-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;
-            }
+export const reportCallbackErrors = (done: DoneCallback) => {
+    return (fAsync: (...args: any[]) => void|Promise<void>) => {
+        const wrapped = async (...args: any[]) => {
             try {
-                f(value);
-                if (expectToBeCalledOnce) {
-                    done();
-                }
+                await fAsync(...args);
             } catch (err) {
                 done(err);
             }
@@ -24,43 +12,3 @@ export const reportNoErrorCallbackErrors = (done: DoneCallback, expectToBeCalled
         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/rpc.ts

@@ -0,0 +1,57 @@
+import * as ethUtil from 'ethereumjs-util';
+import * as request from 'request-promise-native';
+import {constants} from './constants';
+
+export class RPC {
+    private host: string;
+    private port: number;
+    private id: number;
+    constructor() {
+        this.host = constants.RPC_HOST;
+        this.port = constants.RPC_PORT;
+        this.id = 0;
+    }
+    public async takeSnapshotAsync(): Promise<number> {
+        const method = 'evm_snapshot';
+        const params: any[] = [];
+        const payload = this.toPayload(method, params);
+        const snapshotIdHex = await this.sendAsync(payload);
+        const snapshotId = ethUtil.bufferToInt(ethUtil.toBuffer(snapshotIdHex));
+        return snapshotId;
+    }
+    public async revertSnapshotAsync(snapshotId: number): Promise<boolean> {
+        const method = 'evm_revert';
+        const params = [snapshotId];
+        const payload = this.toPayload(method, params);
+        const didRevert = await this.sendAsync(payload);
+        return didRevert;
+    }
+    public async mineBlockAsync(): Promise<void> {
+        const method = 'evm_mine';
+        const params: any[] = [];
+        const payload = this.toPayload(method, params);
+        await this.sendAsync(payload);
+    }
+    private toPayload(method: string, params: any[] = []): string {
+        const payload = JSON.stringify({
+            id: this.id,
+            method,
+            params,
+        });
+        this.id += 1;
+        return payload;
+    }
+    private async sendAsync(payload: string): Promise<any> {
+        const opts = {
+            method: 'POST',
+            uri: `http://${this.host}:${this.port}`,
+            body: payload,
+            headers: {
+                'content-type': 'application/json',
+            },
+        };
+        const bodyString = await request(opts);
+        const body = JSON.parse(bodyString);
+        return body.result;
+    }
+}

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

@@ -1,33 +1,24 @@
 import * as _ from 'lodash';
-
-import { InternalZeroExError, Token } from '../../src/types';
+import {Token, InternalZeroExError} from '../../src/types';
 
 const PROTOCOL_TOKEN_SYMBOL = 'ZRX';
-const WETH_TOKEN_SYMBOL = 'WETH';
 
 export class TokenUtils {
-    private _tokens: Token[];
+    private tokens: Token[];
     constructor(tokens: Token[]) {
-        this._tokens = tokens;
+        this.tokens = tokens;
     }
     public getProtocolTokenOrThrow(): Token {
-        const zrxToken = _.find(this._tokens, { symbol: PROTOCOL_TOKEN_SYMBOL });
+        const zrxToken = _.find(this.tokens, {symbol: PROTOCOL_TOKEN_SYMBOL});
         if (_.isUndefined(zrxToken)) {
             throw new Error(InternalZeroExError.ZrxNotInTokenRegistry);
         }
         return zrxToken;
     }
-    public getWethTokenOrThrow(): Token {
-        const wethToken = _.find(this._tokens, { symbol: WETH_TOKEN_SYMBOL });
-        if (_.isUndefined(wethToken)) {
-            throw new Error(InternalZeroExError.WethNotInTokenRegistry);
-        }
-        return wethToken;
-    }
-    public getDummyTokens(): Token[] {
-        const dummyTokens = _.filter(this._tokens, token => {
-            return !_.includes([PROTOCOL_TOKEN_SYMBOL, WETH_TOKEN_SYMBOL], token.symbol);
+    public getNonProtocolTokens(): Token[] {
+        const nonProtocolTokens = _.filter(this.tokens, token => {
+            return token.symbol !== PROTOCOL_TOKEN_SYMBOL;
         });
-        return dummyTokens;
+        return nonProtocolTokens;
     }
 }

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

@@ -0,0 +1,31 @@
+// HACK: web3 injects XMLHttpRequest into the global scope and ProviderEngine checks XMLHttpRequest
+// to know whether it is running in a browser or node environment. We need it to be undefined since
+// we are not running in a browser env.
+// Filed issue: https://github.com/ethereum/web3.js/issues/844
+(global as any).XMLHttpRequest = undefined;
+import ProviderEngine = require('web3-provider-engine');
+import RpcSubprovider = require('web3-provider-engine/subproviders/rpc');
+import * as Web3 from 'web3';
+import {constants} from './constants';
+import {EmptyWalletSubProvider} from '../../src/subproviders/empty_wallet_subprovider';
+
+export const web3Factory = {
+    create(hasAddresses: boolean = true): Web3 {
+        const provider = this.getRpcProvider(hasAddresses);
+        const web3 = new Web3();
+        web3.setProvider(provider);
+        return web3;
+    },
+    getRpcProvider(hasAddresses: boolean = true): Web3.Provider {
+        const provider = new ProviderEngine();
+        const rpcUrl = `http://${constants.RPC_HOST}:${constants.RPC_PORT}`;
+        if (!hasAddresses) {
+            provider.addProvider(new EmptyWalletSubProvider());
+        }
+        provider.addProvider(new RpcSubprovider({
+            rpcUrl,
+        }));
+        provider.start();
+        return provider;
+    },
+};

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

@@ -1,6 +0,0 @@
-import { web3Factory } from '@0xproject/dev-utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import * as Web3 from 'web3';
-
-export const web3 = web3Factory.create();
-export const web3Wrapper = new Web3Wrapper(web3.currentProvider);

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

@@ -0,0 +1,29 @@
+import * as chai from 'chai';
+import {web3Factory} from './utils/web3_factory';
+import {ZeroEx} from '../src/';
+import {Web3Wrapper} from '../src/web3_wrapper';
+import {constants} from './utils/constants';
+
+chai.config.includeStack = true;
+const expect = chai.expect;
+
+describe('Web3Wrapper', () => {
+    const web3Provider = web3Factory.create().currentProvider;
+    describe('#getNetworkIdIfExistsAsync', () => {
+        it('caches network id requests', async () => {
+            const web3Wrapper = (new ZeroEx(web3Provider) as any)._web3Wrapper as Web3Wrapper;
+            expect((web3Wrapper as any).networkIdIfExists).to.be.undefined();
+            const networkIdIfExists = await web3Wrapper.getNetworkIdIfExistsAsync();
+            expect((web3Wrapper as any).networkIdIfExists).to.be.equal(constants.TESTRPC_NETWORK_ID);
+        });
+        it('invalidates network id cache on setProvider call', async () => {
+            const web3Wrapper = (new ZeroEx(web3Provider) as any)._web3Wrapper as Web3Wrapper;
+            expect((web3Wrapper as any).networkIdIfExists).to.be.undefined();
+            const networkIdIfExists = await web3Wrapper.getNetworkIdIfExistsAsync();
+            expect((web3Wrapper as any).networkIdIfExists).to.be.equal(constants.TESTRPC_NETWORK_ID);
+            const newProvider = web3Factory.create().currentProvider;
+            web3Wrapper.setProvider(newProvider);
+            expect((web3Wrapper as any).networkIdIfExists).to.be.undefined();
+        });
+    });
+});

packages/0x.js/tsconfig.json

@@ -1,7 +1,22 @@
 {
-    "extends": "../../tsconfig",
-    "compilerOptions": {
-        "outDir": "lib"
-    },
-    "include": ["./src/**/*", "./test/**/*"]
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "lib": [ "es2015", "dom" ],
+    "outDir": "lib",
+    "sourceMap": true,
+    "declaration": true,
+    "noImplicitAny": true,
+    "experimentalDecorators": true,
+    "strictNullChecks": true
+  },
+  "include": [
+    "./src/**/*",
+    "./test/**/*",
+    "../../node_modules/types-bn/index.d.ts",
+    "../../node_modules/types-ethereumjs-util/index.d.ts",
+    "../../node_modules/web3-typescript-typings/index.d.ts",
+    "../../node_modules/chai-typescript-typings/index.d.ts",
+    "../../node_modules/chai-as-promised-typescript-typings/index.d.ts"
+  ]
 }

packages/0x.js/tslint.json

@@ -1,3 +1,5 @@
 {
-    "extends": ["@0xproject/tslint-config"]
+  "extends": [
+    "@0xproject/tslint-config"
+  ]
 }

packages/0x.js/webpack.config.js

@@ -7,10 +7,10 @@ const path = require('path');
 const production = process.env.NODE_ENV === 'production';
 
 let entry = {
-    index: './src/index.ts',
+    'index': './src/index.ts',
 };
 if (production) {
-    entry = _.assign({}, entry, { 'index.min': './src/index.ts' });
+    entry = _.assign({}, entry, {'index.min': './src/index.ts'});
 }
 
 module.exports = {

packages/abi-gen/.npmignore

@@ -1,6 +0,0 @@
-.*
-yarn-error.log
-/src/
-/scripts/
-tsconfig.json
-/lib/monorepo_scripts/

packages/abi-gen/CHANGELOG.json

@@ -1,99 +0,0 @@
-[
-    {
-        "timestamp": 1522673609,
-        "version": "0.2.9",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ]
-    },
-    {
-        "timestamp": 1522658513,
-        "version": "0.2.8",
-        "changes": [
-            {
-                "note": "Dependencies updated"
-            }
-        ],
-        "isPublished": true
-    },
-    {
-        "version": "0.2.5",
-        "changes": [
-            {
-                "note": "Consolidate all `console.log` calls into `logUtils` in the `@0xproject/utils` package",
-                "pr": 452
-            }
-        ],
-        "timestamp": 1521298800,
-        "isPublished": true
-    },
-    {
-        "version": "0.2.4",
-        "changes": [
-            {
-                "note":
-                    "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`",
-                "pr": 413
-            },
-            {
-                "note":
-                    "Add support for [tuple types](https://solidity.readthedocs.io/en/develop/abi-spec.html#handling-tuple-types)",
-                "pr": 413
-            },
-            {
-                "note": "Add `hasReturnValue` to context data",
-                "pr": 413
-            }
-        ],
-        "timestamp": 1520089200,
-        "isPublished": true
-    },
-    {
-        "version": "0.2.1",
-        "changes": [
-            {
-                "note": "Fix publishing issue where .npmignore was not properly excluding undesired content",
-                "pr": 389
-            }
-        ],
-        "timestamp": 1518102000,
-        "isPublished": true
-    },
-    {
-        "version": "0.2.0",
-        "changes": [
-            {
-                "note": "Added CLI options for explicit specifying location of partials and main template",
-                "pr": 346
-            },
-            {
-                "note":
-                    "Added CLI option to specify networkId, adding support for the JSON artifact format found in @0xproject/contracts",
-                "pr": 388
-            }
-        ],
-        "timestamp": 1517929200,
-        "isPublished": true
-    },
-    {
-        "version": "0.1.0",
-        "changes": [
-            {
-                "note": "Fixed array typings with union types",
-                "pr": 295
-            },
-            {
-                "note": "Add event ABIs to context data passed to templates",
-                "pr": 302
-            },
-            {
-                "note": "Add constructor ABIs to context data passed to templates",
-                "pr": 304
-            }
-        ],
-        "timestamp": 1515596400,
-        "isPublished": true
-    }
-]

packages/abi-gen/CHANGELOG.md

@@ -1,39 +0,0 @@
-<!--
-This file is auto-generated using the monorepo-scripts package. Don't edit directly.
-Edit the package's CHANGELOG.json file only.
--->
-
-CHANGELOG
-
-## v0.2.9 - _April 2, 2018_
-
-    * Dependencies updated
-
-## v0.2.8 - _April 2, 2018_
-
-    * Dependencies updated
-
-## v0.2.5 - _March 17, 2018_
-
-    * Consolidate all `console.log` calls into `logUtils` in the `@0xproject/utils` package (#452)
-
-## 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 8, 2018_
-
-    * Fix publishing issue where .npmignore was not properly excluding undesired content (#389)
-
-## 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 10, 2018_
-
-    * Fixed array typings with union types (#295)
-    * Add event ABIs to context data passed to templates (#302)
-    * Add constructor ABIs to context data passed to templates (#304)

packages/abi-gen/README.md

@@ -1,59 +0,0 @@
-# ABI Gen
-
-This package allows you to generate TypeScript contract wrappers from ABI files.
-It's heavily inspired by [Geth abigen](https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts) but takes a different approach.
-You can write your custom handlebars templates which will allow you to seamlessly integrate the generated code into your existing codebase with existing conventions.
-
-For an example of the generated [wrapper files](https://github.com/0xProject/0x-monorepo/tree/development/packages/0x.js/src/contract_wrappers/generated) check out 0x.js.
-[Here](https://github.com/0xProject/0x-monorepo/tree/development/packages/0x.js/contract_templates) are the templates used to generate those files.
-
-## Installation
-
-`yarn add -g @0xproject/abi-gen`
-
-## Usage
-
-```
-abi-gen
-Options:
-  --help               Show help                                       [boolean]
-  --version            Show version number                             [boolean]
-  --abis               Glob pattern to search for ABI JSON files
-                                                             [string] [required]
-  --output, -o, --out  Folder where to put the output files  [string] [required]
-  --partials           Glob pattern for the partial template files      [string]
-  --template           Path for the main template file that will be used to
-                       generate each contract                [string] [required]
-  --backend            The backing Ethereum library your app uses. Either 'web3'
-                       or 'ethers'. Ethers auto-converts small ints to numbers
-                       whereas Web3 doesn't.
-                          [string] [choices: "web3", "ethers"] [default: "web3"]
-  --network-id         ID of the network where contract ABIs are nested in
-                       artifacts                          [number] [default: 50]
-```
-
-You're required to pass a [glob](<https://en.wikipedia.org/wiki/Glob_(programming)>) template where your abi files are located.
-TL;DR - here is the example from 0x.js.
-
-`--abis 'src/artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry).json`
-
-We could've just used `--abis 'src/artifacts/*.json` but we wanted to exclude some of the abi files.
-
-The abi file should be either a [Truffle](http://truffleframework.com/) contract artifact (a JSON object with an abi key) or a JSON abi array.
-
-You need to also specify the location of your main template used for every contract `--template` as well as the partial templates `--partials` that can later be used from the main one.
-
-## How to write custom templates?
-
-The best way to get started is to copy [0x.js templates](https://github.com/0xProject/0x-monorepo/tree/development/packages/0x.js/contract_templates) and start adjusting them for your needs.
-We use [handlebars](http://handlebarsjs.com/) template engine under the hood.
-You need to have a master template called `contract.mustache`. it will be used to generate each contract wrapper. Although - you don't need and probably shouldn't write all your logic in a single template file. You can write [partial templates](http://handlebarsjs.com/partials.html) and as long as they are within a partials folder - they will be registered and available.
-
-## Which data/context do I get in my templates?
-
-For now you don't get much on top of methods abi, some useful helpers and a contract name because it was enough for our use-case, but if you need something else - create a PR.
-See the [type definition](https://github.com/0xProject/0x-monorepo/tree/development/packages/abi-gen/src/types.ts) of what we pass to the render method.
-
-## Output files
-
-Output files will be generated within an output folder with names converted to camel case and taken from abi file names. If you already have some files in that folder they will be overwritten.