Publish

- 0x.js@0.36.1
 - @0xproject/abi-gen@0.2.11
 - @0xproject/assert@0.2.7
 - @0xproject/base-contract@0.2.1
 - @0xproject/connect@0.6.10
 - contracts@2.1.23
 - @0xproject/deployer@0.4.1
 - @0xproject/dev-utils@0.3.6
 - @0xproject/json-schemas@0.7.21
 - @0xproject/metacoin@0.0.4
 - @0xproject/migrations@0.0.2
 - @0xproject/monorepo-scripts@0.1.18
 - @0xproject/react-docs-example@0.0.8
 - @0xproject/react-docs@0.0.8
 - @0xproject/react-shared@0.1.3
 - @0xproject/sol-cov@0.0.8
 - @0xproject/sol-resolver@0.0.2
 - @0xproject/sra-report@0.0.9
 - @0xproject/subproviders@0.9.0
 - @0xproject/testnet-faucets@1.0.24
 - @0xproject/tslint-config@0.4.16
 - @0xproject/types@0.6.1
 - @0xproject/typescript-typings@0.2.0
 - @0xproject/utils@0.5.2
 - @0xproject/web3-wrapper@0.6.1
 - @0xproject/website@0.0.26

.circleci/config.yml

@@ -27,6 +27,15 @@ jobs:
           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
@@ -40,6 +49,10 @@ jobs:
           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
@@ -53,6 +66,10 @@ jobs:
           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
@@ -66,6 +83,10 @@ jobs:
           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
@@ -79,6 +100,34 @@ jobs:
           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
+      - save_cache:
+          key: coverage-metacoin-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/metacoin/coverage/lcov.info
   lint:
     working_directory: ~/repo
     docker:
@@ -97,11 +146,53 @@ jobs:
           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 }}
+      - restore_cache:
+          keys:
+            - coverage-metacoin-{{ .Environment.CIRCLE_SHA1 }}
+      - run: yarn report_coverage
 workflows:
   version: 2
   main:
     jobs:
       - build
+      - test-installation:
+          requires:
+            - build
       - test-0xjs:
           requires:
             - build
@@ -120,3 +211,9 @@ workflows:
       - lint:
           requires:
             - build
+      - submit-coverage:
+          requires:
+            - test-0xjs
+            - test-deployer
+            - test-rest
+            - test-contracts

.gitignore

@@ -68,6 +68,24 @@ generated_docs/
 TODO.md
 
 packages/website/public/bundle*
+packages/react-docs/example/public/bundle*
 
 # generated binaries
 bin/
+
+# generated contract artifacts
+packages/sol-cov/test/fixtures/artifacts
+packages/metacoin/artifacts
+packages/0x.js/test/artifacts
+packages/migrations/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/

.prettierignore

@@ -1,5 +1,7 @@
 lib
-generated
 .nyc_output
-/packages/contracts/build/contracts
+/packages/contracts/src/artifacts
+/packages/metacoin/artifacts
+/packages/migrations/src/artifacts
 package.json
+scripts/postpublish_utils.js

CONTRIBUTING.md

@@ -8,9 +8,9 @@ If you'd like to contribute to 0x protocol, please fork the repo, fix, commit an
 
 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:
 
-* 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/)
+*   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/)
 
 ### Code quality
 
@@ -23,7 +23,7 @@ If the sub-package you are modifying has a `CHANGELOG.md` file, make sure to add
 
 ### Styleguide
 
-We use [TSLint](https://palantir.github.io/tslint/) with [custom configs](https://github.com/0xProject/0x.js/tree/development/packages/tslint-config) to keep our code style consistent.
+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 lint your code just run: `yarn lint`
 
@@ -31,10 +31,10 @@ We also use [Prettier](https://prettier.io/) to auto-format our code. Be sure to
 
 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)
+*   [prettier-atom](https://atom.io/packages/prettier-atom)
+*   [language-ethereum](https://atom.io/packages/language-ethereum)
 
 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.
 

PULL_REQUEST_TEMPLATE.md

@@ -24,9 +24,9 @@
 
 <!--- 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)
+*   [ ] 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:
 
@@ -34,9 +34,8 @@
 
 <!--- 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.
+*   [ ] Change requires a change to the documentation.
+*   [ ] Added tests to cover my changes.
+*   [ ] Added new entries to the relevant CHANGELOG.jsons.
+*   [ ] 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.

README.md

@@ -4,60 +4,76 @@
 
 [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 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.
+This repository is a monorepo including the 0x protocol smart contracts and numerous developer tools. Each public sub-package is independently published to NPM.
 
 [website-url]: https://0xproject.com/
 [whitepaper-url]: https://0xproject.com/pdfs/0x_white_paper.pdf
 
-[![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)
+[![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)
 [![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.js.svg?token=7c22e5c72acf39d3ead8d29c5d9bb38f9096df3e643024dcedd53ab732847be1&ts=1496426342666)](https://greenkeeper.io/)
 
 ### Published Packages
 
-| Package                                                                                | Version                                                                                                                                           | Description                                                        |
-| -------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
-| [`0x.js`](/packages/0x.js)                                                             | [![npm](https://img.shields.io/npm/v/0x.js.svg)](https://www.npmjs.com/package/0x.js)                                                             | A Javascript library for interacting with the 0x protocol          |
-| [`chai-as-promised-typescript-typings`](/packages/chai-as-promised-typescript-typings) | [![npm](https://img.shields.io/npm/v/chai-as-promised-typescript-typings.svg)](https://www.npmjs.com/package/chai-as-promised-typescript-typings) | Chai as promised typescript typings                                |
-| [`chai-typescript-typings`](/packages/chai-typescript-typings)                         | [![npm](https://img.shields.io/npm/v/chai-typescript-typings.svg)](https://www.npmjs.com/package/chai-typescript-typings)                         | Chai typescript typings                                            |
-| [`web3-typescript-typings`](/packages/web3-typescript-typings)                         | [![npm](https://img.shields.io/npm/v/web3-typescript-typings.svg)](https://www.npmjs.com/package/web3-typescript-typings)                         | Web3 typescript typings                                            |
-| [`@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/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/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/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/utils`](/packages/utils)                                                  | [![npm](https://img.shields.io/npm/v/@0xproject/utils.svg)](https://www.npmjs.com/package/@0xproject/utils)                                       | Shared utilities                                                   |
-| [`@0xproject/web3-wrapper`](/packages/web3-wrapper)                                    | [![npm](https://img.shields.io/npm/v/@0xproject/web3-wrapper.svg)](https://www.npmjs.com/package/@0xproject/web3-wrapper)                         | Web3 wrapper                                                       |
+| Package                                                         | Version                                                                                                                               | Description                                                                 |
+| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| [`0x.js`](/packages/0x.js)                                      | [![npm](https://img.shields.io/npm/v/0x.js.svg)](https://www.npmjs.com/package/0x.js)                                                 | A Javascript library for interacting with the 0x protocol                   |
+| [`@0xproject/abi-gen`](/packages/abi-gen)                       | [![npm](https://img.shields.io/npm/v/@0xproject/abi-gen.svg)](https://www.npmjs.com/package/@0xproject/abi-gen)                       | Tool to generate TS wrappers from smart contract ABIs                       |
+| [`@0xproject/assert`](/packages/assert)                         | [![npm](https://img.shields.io/npm/v/@0xproject/assert.svg)](https://www.npmjs.com/package/@0xproject/assert)                         | Type and schema assertions used by our packages                             |
+| [`@0xproject/base-contract`](/packages/base-contract)           | [![npm](https://img.shields.io/npm/v/@0xproject/base-contract.svg)](https://www.npmjs.com/package/@0xproject/base-contract)           | BaseContract used by auto-generated `abi-gen` wrapper contracts             |
+| [`@0xproject/connect`](/packages/connect)                       | [![npm](https://img.shields.io/npm/v/@0xproject/connect.svg)](https://www.npmjs.com/package/@0xproject/connect)                       | A Javascript library for interacting with the Standard Relayer API          |
+| [`@0xproject/deployer`](/packages/deployer)                     | [![npm](https://img.shields.io/npm/v/@0xproject/deployer.svg)](https://www.npmjs.com/package/@0xproject/deployer)                     | Solidity project compiler and deployer framework                            |
+| [`@0xproject/dev-utils`](/packages/dev-utils)                   | [![npm](https://img.shields.io/npm/v/@0xproject/dev-utils.svg)](https://www.npmjs.com/package/@0xproject/dev-utils)                   | Dev utils to be shared across 0x projects and packages                      |
+| [`@0xproject/json-schemas`](/packages/json-schemas)             | [![npm](https://img.shields.io/npm/v/@0xproject/json-schemas.svg)](https://www.npmjs.com/package/@0xproject/json-schemas)             | 0x-related json schemas                                                     |
+| [`@0xproject/monorepo-scripts`](/packages/monorepo-scripts)     | [![npm](https://img.shields.io/npm/v/@0xproject/monorepo-scripts.svg)](https://www.npmjs.com/package/@0xproject/monorepo-scripts)     | Monorepo scripts                                                            |
+| [`@0xproject/react-docs`](/packages/react-docs)                 | [![npm](https://img.shields.io/npm/v/@0xproject/react-docs.svg)](https://www.npmjs.com/package/@0xproject/react-docs)                 | React documentation component for rendering TypeDoc & Doxity generated JSON |
+| [`@0xproject/react-shared`](/packages/react-shared)             | [![npm](https://img.shields.io/npm/v/@0xproject/react-shared.svg)](https://www.npmjs.com/package/@0xproject/react-shared)             | 0x shared react components                                                  |
+| [`@0xproject/sra-report`](/packages/sra-report)                 | [![npm](https://img.shields.io/npm/v/@0xproject/sra-report.svg)](https://www.npmjs.com/package/@0xproject/sra-report)                 | Generate reports for standard relayer API compliance                        |
+| [`@0xproject/sol-cov`](/packages/sol-cov)                       | [![npm](https://img.shields.io/npm/v/@0xproject/sol-cov.svg)](https://www.npmjs.com/package/@0xproject/sol-cov)                       | Solidity test coverage tool                                                 |
+| [`@0xproject/subproviders`](/packages/subproviders)             | [![npm](https://img.shields.io/npm/v/@0xproject/subproviders.svg)](https://www.npmjs.com/package/@0xproject/subproviders)             | Useful web3 subproviders (e.g LedgerSubprovider)                            |
+| [`@0xproject/tslint-config`](/packages/tslint-config)           | [![npm](https://img.shields.io/npm/v/@0xproject/tslint-config.svg)](https://www.npmjs.com/package/@0xproject/tslint-config)           | Custom 0x development TSLint rules                                          |
+| [`@0xproject/types`](/packages/types)                           | [![npm](https://img.shields.io/npm/v/@0xproject/types.svg)](https://www.npmjs.com/package/@0xproject/types)                           | Shared type declarations                                                    |
+| [`@0xproject/typescript-typings`](/packages/typescript-typings) | [![npm](https://img.shields.io/npm/v/@0xproject/typescript-typings.svg)](https://www.npmjs.com/package/@0xproject/typescript-typings) | Repository of types for external packages                                   |
+| [`@0xproject/utils`](/packages/utils)                           | [![npm](https://img.shields.io/npm/v/@0xproject/utils.svg)](https://www.npmjs.com/package/@0xproject/utils)                           | Shared utilities                                                            |
+| [`@0xproject/web3-wrapper`](/packages/web3-wrapper)             | [![npm](https://img.shields.io/npm/v/@0xproject/web3-wrapper.svg)](https://www.npmjs.com/package/@0xproject/web3-wrapper)             | Web3 wrapper                                                                |
 
 ### Private Packages
 
-| Package                                                     | Description                                                      |
-| ----------------------------------------------------------- | ---------------------------------------------------------------- |
-| [`@0xproject/contracts`](/packages/contracts)               | 0x solidity smart contracts & tests                              |
-| [`@0xproject/monorepo-scripts`](/packages/monorepo-scripts) | Shared monorepo scripts                                          |
-| [`@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                                         |
+| 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)
-* [Standard Relayer API](https://github.com/0xProject/standard-relayer-api/blob/master/README.md)
+*   [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.
+#### Read our [contribution guidelines](./CONTRIBUTING.md).
 
 ### Install dependencies
 
@@ -75,13 +91,17 @@ yarn install
 
 ### Build
 
-Build all packages
+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:run build
+yarn lerna:rebuild
 ```
 
-Continuously rebuild on exchange
+Or continuously rebuild on change:
 
 ```bash
 yarn dev
@@ -97,24 +117,6 @@ 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
+yarn lerna:test
 ```

lerna.json

@@ -1,6 +1,11 @@
 {
     "lerna": "2.5.1",
     "packages": ["packages/*"],
+    "commands": {
+        "publish": {
+            "allowBranch": "development"
+        }
+    },
     "version": "independent",
     "commands": {
         "publish": {

package.json

@@ -1,27 +1,38 @@
 {
     "private": true,
-    "name": "0x.js",
-    "workspaces": ["packages/*"],
+    "name": "0x-monorepo",
+    "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:rebuild": "lerna run clean; lerna run build;",
-        "lerna:publish":
-            "yarn install; lerna run clean; lerna run build; lerna publish --registry=https://registry.npmjs.org/"
+        "lerna:test": "lerna run test",
+        "lerna:clean": "lerna run clean",
+        "lerna:build": "lerna run build",
+        "lerna:rebuild": "run-s lerna:clean lerna:build",
+        "lerna:publish": "run-s lerna:install lerna:rebuild script:publish",
+        "lerna:publish:dry": "run-s lerna:install lerna:rebuild script:publish:dry",
+        "lerna:stage_docs": "lerna run docs:stage",
+        "script:publish": "node ./packages/monorepo-scripts/lib/publish.js",
+        "script:publish:dry": "IS_DRY_RUN=true yarn script:publish"
     },
     "config": {
         "mnemonic": "concert load couple harbor equip island argue ramp clarify fence smart topic"
     },
     "devDependencies": {
-        "@0xproject/utils": "^0.3.1",
         "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",
-        "prettier": "1.9.2",
-        "publish-release": "0xproject/publish-release",
-        "semver-sort": "^0.0.4"
+        "npm-run-all": "^4.1.2",
+        "prettier": "^1.11.1"
     }
 }

packages/0x.js/.npmignore

@@ -8,3 +8,4 @@ test/
 /contract_templates/
 /generated_docs/
 /scripts/
+/lib/src/monorepo_scripts/

packages/0x.js/CHANGELOG.json

@@ -0,0 +1,995 @@
+[
+    {
+        "version": "0.36.1",
+        "changes": [
+            {
+                "note": "Internal changes and refactoring"
+            },
+            {
+                "note": "Fix redundant expired order removal bug",
+                "pr": 527
+            }
+        ],
+        "timestamp": 1524044013
+    },
+    {
+        "version": "0.36.0",
+        "changes": [
+            {
+                "note": "Moved Web3.Provider to `@0xproject/types:Provider`",
+                "pr": 501
+            },
+            {
+                "note":
+                    "Add `zeroEx.exchange.getOrderStateAsync` to allow obtaining current OrderState for a signedOrder",
+                "pr": 510
+            }
+        ],
+        "timestamp": 1523462196
+    },
+    {
+        "version": "0.35.0",
+        "changes": [
+            {
+                "note":
+                    "Removed `ZeroExError.TransactionMiningTimeout` and moved it to '@0xproject/web3-wrapper' `Web3WrapperErrors.TransactionMiningTimeout`",
+                "pr": 485
+            }
+        ],
+        "timestamp": 1522673609
+    },
+    {
+        "version": "0.34.0",
+        "changes": [
+            {
+                "note":
+                    "Fix the bug causing `zeroEx.exchange.fillOrdersUpToAsync` validation to fail if there were some extra orders passed",
+                "pr": 470
+            },
+            {
+                "note": "Remove automatic instantiation of `zeroEx.orderStateWatcher`",
+                "pr": 488
+            },
+            {
+                "note": "Add `zeroEx.createOrderStateWatcher` to allow creating arbitrary number of OrderStateWatchers",
+                "pr": 488
+            },
+            {
+                "note":
+                    "Added `stateLayer` setting to `OrderStateWatcherConfig` so OrderStateWatcher can be set to monitor different blockchain state layers",
+                "pr": 488
+            }
+        ],
+        "timestamp": 1522658513
+    },
+    {
+        "version": "0.33.2",
+        "changes": [
+            {
+                "note": "Consolidate all `console.log` calls into `logUtils` in the `@0xproject/utils` package",
+                "pr": 452
+            },
+            {
+                "note": "Consolidate `Order`, `SignedOrder`, and `ECSignature` into the `@0xproject/types` package",
+                "pr": 456
+            }
+        ],
+        "timestamp": 1521298800
+    },
+    {
+        "version": "0.33.1",
+        "changes": [
+            {
+                "note": "Add missing EthersJs typescript typings as dependency"
+            }
+        ],
+        "timestamp": 1520434800
+    },
+    {
+        "version": "0.33.0",
+        "changes": [
+            {
+                "note": "Validate and lowercase all addresses in public methods",
+                "pr": 373
+            },
+            {
+                "note": "Improve validation to force passing contract addresses on private networks",
+                "pr": 385
+            },
+            {
+                "note": "Change `LogErrorContractEventArgs.errorId` type from `BigNumber` to `number`",
+                "pr": 413
+            },
+            {
+                "note": "Rename all public `_unsubscribeAll` methods to `unsubscribeAll`",
+                "pr": 415
+            },
+            {
+                "note": "Move web3 typings from devDep to dep since cannot use this package without it",
+                "pr": 429
+            }
+        ],
+        "timestamp": 1520089200
+    },
+    {
+        "version": "0.32.2",
+        "changes": [
+            {
+                "note": "Fix publishing issue where .npmignore was not properly excluding undesired content",
+                "pr": 389
+            }
+        ],
+        "timestamp": 1518102000
+    },
+    {
+        "version": "0.32.1",
+        "changes": [
+            {
+                "note": "Reorganized `BlockParamLiteral` export into `@0xproject/types` package",
+                "pr": 355
+            },
+            {
+                "note": "Now using `abi-gen` package to generate ContractEventArgs types",
+                "pr": 371
+            }
+        ],
+        "timestamp": 1517929200
+    },
+    {
+        "version": "0.32.0",
+        "changes": [
+            {
+                "note": "Add `zeroEx.etherToken.getContractAddressIfExists`",
+                "pr": 350
+            },
+            {
+                "note":
+                    "Fixed the bug causing order watcher to throw if there is an event with the same signature but different indexed fields",
+                "pr": 366
+            }
+        ],
+        "timestamp": 1517756400
+    },
+    {
+        "version": "0.31.1",
+        "changes": [
+            {
+                "note": "Fix the bug causing order watcher to throw if makerToken === zrx",
+                "pr": 357
+            }
+        ],
+        "timestamp": 1517410800
+    },
+    {
+        "version": "0.31.0",
+        "changes": [
+            {
+                "note":
+                    "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.",
+                "pr": 349
+            }
+        ],
+        "timestamp": 1517238000
+    },
+    {
+        "version": "0.30.2",
+        "changes": [
+            {
+                "note": "Add Rinkeby testnet addresses to artifacts ",
+                "pr": 337
+            },
+            {
+                "note": "Move @0xproject/types to dependencies from devDependencies fixing missing type errors"
+            }
+        ],
+        "timestamp": 1517151600
+    },
+    {
+        "version": "0.30.1",
+        "changes": [
+            {
+                "note": "Fix a bug allowing negative fill values ",
+                "pr": 212
+            },
+            {
+                "note": "Fix a bug that made it impossible to pass a custom ZRX address ",
+                "pr": 341
+            }
+        ],
+        "timestamp": 1516719600
+    },
+    {
+        "version": "0.30.0",
+        "changes": [
+            {
+                "note": "Add an error parameter to the order watcher callback",
+                "pr": 312
+            },
+            {
+                "note": "Fix a bug making it impossible to catch some errors from awaitTransactionMinedAsync",
+                "pr": 312
+            },
+            {
+                "note":
+                    "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",
+                "pr": 321
+            }
+        ],
+        "timestamp": 1516114800
+    },
+    {
+        "version": "0.29.1",
+        "changes": [
+            {
+                "note": "Fixed bignumber config issue #301",
+                "pr": 305
+            }
+        ],
+        "timestamp": 1515596400
+    },
+    {
+        "version": "0.29.0",
+        "changes": [
+            {
+                "note": "Assert baseUnit amount supplied to `toUnitAmount` is integer amount.",
+                "pr": 287
+            },
+            {
+                "note": "`toBaseUnitAmount` throws if amount supplied has too many decimals",
+                "pr": 287
+            }
+        ],
+        "timestamp": 1514386800
+    },
+    {
+        "version": "0.28.0",
+        "changes": [
+            {
+                "note":
+                    "Add `etherTokenAddress` arg to `depositAsync` and `withdrawAsync` methods on `zeroEx.etherToken`",
+                "pr": 267
+            },
+            {
+                "note":
+                    "Removed accidentally included `unsubscribeAll` method from `zeroEx.proxy`, `zeroEx.etherToken` and `zeroEx.tokenRegistry`",
+                "pr": 267
+            },
+            {
+                "note": "Removed `etherTokenContractAddress` from `ZeroEx` constructor arg `ZeroExConfig`",
+                "pr": 267
+            },
+            {
+                "note": "Rename `SubscriptionOpts` to `BlockRange`",
+                "pr": 272
+            },
+            {
+                "note":
+                    "Add `zeroEx.etherToken.subscribe`, `zeroEx.etherToken.unsubscribe`, `zeroEx.etherToken.unsubscribeAll`",
+                "pr": 277
+            },
+            {
+                "note": "Add `zeroEx.etherToken.getLogsAsync`",
+                "pr": 277
+            },
+            {
+                "note":
+                    "Add new public types `BlockParamLiteral`, `EtherTokenEvents`, `EtherTokenContractEventArgs`, `DepositContractEventArgs`, `WithdrawalContractEventArgs`",
+                "pr": 277
+            },
+            {
+                "note": "Support `Deposit` and `Withdraw` events on etherToken",
+                "pr": 277
+            },
+            {
+                "note": "Improve the error message when taker is not a string",
+                "pr": 278
+            }
+        ],
+        "timestamp": 1513695600
+    },
+    {
+        "version": "0.27.1",
+        "changes": [
+            {
+                "note": "Export `TransactionOpts` type"
+            }
+        ],
+        "timestamp": 1511794800
+    },
+    {
+        "version": "0.27.0",
+        "changes": [
+            {
+                "note": "Make `ZeroExConfig` required parameter of `ZeroEx` constructor",
+                "pr": 233
+            },
+            {
+                "note": "Add a required property `networkId` to `ZeroExConfig`",
+                "pr": 233
+            },
+            {
+                "note":
+                    "Make all `getContractAddress` functions, `zeroEx.exchange.subscribe`, `zeroEx.exchange.getZRXTokenAddress` sync",
+                "pr": 233
+            },
+            {
+                "note": "Remove `ZeroExError.ContractNotFound` and replace it with contract-specific errors",
+                "pr": 233
+            },
+            {
+                "note":
+                    "Make `DecodedLogEvent<A>` contain `LogWithDecodedArgs<A>` under log key instead of merging it in like web3 does",
+                "pr": 234
+            },
+            {
+                "note": "Rename `removed` to `isRemoved` in `DecodedLogEvent<A>`",
+                "pr": 234
+            },
+            {
+                "note": "Add config allowing to specify gasPrice and gasLimit for every transaction sending method",
+                "pr": 235
+            },
+            {
+                "note": "All transaction sending methods now call `estimateGas` if no gas amount was supplied",
+                "pr": 235
+            },
+            {
+                "note":
+                    "Modify order validation methods to validate against the `latest` block, not against the `pending` block",
+                "pr": 236
+            }
+        ],
+        "timestamp": 1511794800
+    },
+    {
+        "version": "0.26.0",
+        "changes": [
+            {
+                "note":
+                    "Add post-formatter for logs converting `blockNumber`, `logIndex`, `transactionIndex` from hexes to numbers",
+                "pr": 231
+            },
+            {
+                "note": "Remove support for Async callback types when used in Subscribe functions",
+                "pr": 222
+            },
+            {
+                "note":
+                    "In OrderWatcher subscribe to ZRX Token Transfer and Approval events when maker token is different",
+                "pr": 225
+            }
+        ],
+        "timestamp": 1511190000
+    },
+    {
+        "version": "0.25.1",
+        "changes": [
+            {
+                "note": "Standardise on Cancelled over Canceled",
+                "pr": 217
+            },
+            {
+                "note": "Add missing `DecodedLogEvent` type to exported types",
+                "pr": 205
+            },
+            {
+                "note":
+                    "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.",
+                "pr": 200
+            }
+        ],
+        "timestamp": 1510498800
+    },
+    {
+        "version": "0.23.0",
+        "changes": [
+            {
+                "note": "Fixed unhandled promise rejection error in subscribe methods",
+                "pr": 209
+            },
+            {
+                "note": "Subscribe callbacks now receive an error object as their first argument"
+            }
+        ],
+        "timestamp": 1510412400
+    },
+    {
+        "version": "0.22.6",
+        "changes": [
+            {
+                "note": "Add a timeout parameter to transaction awaiting",
+                "pr": 206
+            }
+        ],
+        "timestamp": 1510239600
+    },
+    {
+        "version": "0.22.5",
+        "changes": [
+            {
+                "note": "Re-publish v0.22.4 to fix publishing issue"
+            }
+        ],
+        "timestamp": 1509980400
+    },
+    {
+        "version": "0.22.4",
+        "changes": [
+            {
+                "note": "Upgraded bignumber.js to a new version that ships with native typings"
+            }
+        ],
+        "timestamp": 1508857200
+    },
+    {
+        "version": "0.22.3",
+        "changes": [
+            {
+                "note": "Fixed an issue with new version of testrpc and unlimited proxy allowance",
+                "pr": 199
+            }
+        ],
+        "timestamp": 1508857200
+    },
+    {
+        "version": "0.22.2",
+        "changes": [
+            {
+                "note": "Fixed rounding of maker fill amount and incorrect validation of partial fees",
+                "pr": 197
+            }
+        ],
+        "timestamp": 1508770800
+    },
+    {
+        "version": "0.22.0",
+        "changes": [
+            {
+                "note":
+                    "Started using `OrderFillRequest` interface instead of `OrderFillOrKillRequest` interface for `zeroEx.exchange.batchFillOrKill`",
+                "pr": 187
+            },
+            {
+                "note": "Removed `OrderFillOrKillRequest`",
+                "pr": 187
+            }
+        ],
+        "timestamp": 1508079600
+    },
+    {
+        "version": "0.21.4",
+        "changes": [
+            {
+                "note":
+                    "Made 0x.js more type-safe by making `getLogsAsync` and `subscribe/subscribeAsync` generics parametrized with arg type",
+                "pr": 194
+            }
+        ],
+        "timestamp": 1507820400
+    },
+    {
+        "version": "0.21.3",
+        "changes": [
+            {
+                "note": "Fixed a bug causing order fills to throw `INSUFFICIENT_TAKER_ALLOWANCE`",
+                "pr": 193
+            }
+        ],
+        "timestamp": 1507734000
+    },
+    {
+        "version": "0.21.2",
+        "changes": [
+            {
+                "note": "Exported `ContractEventArg` as a public type",
+                "pr": 190
+            }
+        ],
+        "timestamp": 1507647600
+    },
+    {
+        "version": "0.21.1",
+        "changes": [
+            {
+                "note": "Fixed a bug in subscriptions",
+                "pr": 189
+            }
+        ],
+        "timestamp": 1507647600
+    },
+    {
+        "version": "0.21.0",
+        "changes": [
+            {
+                "note": "Complete rewrite of subscription logic",
+                "pr": 182
+            },
+            {
+                "note": "Subscriptions no longer return historical logs. If you want them - use `getLogsAsync`"
+            },
+            {
+                "note":
+                    "Subscriptions now use [ethereumjs-blockstream](https://github.com/ethereumjs/ethereumjs-blockstream) under the hood"
+            },
+            {
+                "note": "Subscriptions correctly handle block re-orgs (forks)"
+            },
+            {
+                "note": "Subscriptions correctly backfill logs (connection problems)"
+            },
+            {
+                "note":
+                    "They no longer setup filters on the underlying nodes, so you can use them with infura without a filter Subprovider"
+            },
+            {
+                "note": "Removed `ContractEventEmitter` and added `LogEvent`"
+            },
+            {
+                "note": "Renamed `zeroEx.token.subscribeAsync` to `zeroEx.token.subscribe`"
+            },
+            {
+                "note": "Added `zeroEx.token.unsubscribe` and `zeroEx.exchange.unsubscribe`"
+            },
+            {
+                "note": "Renamed `zeroEx.exchange.stopWatchingAllEventsAsync` to `zeroEx.exhange.unsubscribeAll`"
+            },
+            {
+                "note": "Renamed `zeroEx.token.stopWatchingAllEventsAsync` to `zeroEx.token.unsubscribeAll`"
+            },
+            {
+                "note": "Fixed the batch fills validation by emulating all balance & proxy allowance changes",
+                "pr": 185
+            }
+        ],
+        "timestamp": 1507561200
+    },
+    {
+        "version": "0.20.0",
+        "changes": [
+            {
+                "note": "Add `zeroEx.token.getLogsAsync`",
+                "pr": 178
+            },
+            {
+                "note": "Add `zeroEx.exchange.getLogsAsync`",
+                "pr": 178
+            },
+            {
+                "note": "Fixed fees validation when one of the tokens transferred is ZRX",
+                "pr": 181
+            }
+        ],
+        "timestamp": 1507129200
+    },
+    {
+        "version": "0.19.0",
+        "changes": [
+            {
+                "note": "Made order validation optional ",
+                "pr": 172
+            },
+            {
+                "note": "Added Ropsten testnet support",
+                "pr": 173
+            },
+            {
+                "note": "Fixed a bug causing awaitTransactionMinedAsync to DDos backend nodes",
+                "pr": 175
+            }
+        ],
+        "timestamp": 1506610800
+    },
+    {
+        "version": "0.18.0",
+        "changes": [
+            {
+                "note": "Added `zeroEx.exchange.validateOrderFillableOrThrowAsync` to simplify orderbook pruning",
+                "pr": 170
+            }
+        ],
+        "timestamp": 1506351600
+    },
+    {
+        "version": "0.17.0",
+        "changes": [
+            {
+                "note": "Made `zeroEx.exchange.getZRXTokenAddressAsync` public",
+                "pr": 171
+            }
+        ],
+        "timestamp": 1506351600
+    },
+    {
+        "version": "0.16.0",
+        "changes": [
+            {
+                "note": "Added the ability to specify custom contract addresses to be used with 0x.js",
+                "pr": 165
+            },
+            {
+                "note": "ZeroExConfig.exchangeContractAddress"
+            },
+            {
+                "note": "ZeroExConfig.tokenRegistryContractAddress"
+            },
+            {
+                "note": "ZeroExConfig.etherTokenContractAddress"
+            },
+            {
+                "note": "Added `zeroEx.tokenRegistry.getContractAddressAsync`",
+                "pr": 165
+            }
+        ],
+        "timestamp": 1505833200
+    },
+    {
+        "version": "0.15.0",
+        "changes": [
+            {
+                "note":
+                    "Added the ability to specify a historical `blockNumber` at which to query the blockchain's state when calling a token or exchange method",
+                "pr": 161
+            }
+        ],
+        "timestamp": 1504796400
+    },
+    {
+        "version": "0.14.2",
+        "changes": [
+            {
+                "note": "Fixed an issue with bignumber.js types not found",
+                "pr": 160
+            }
+        ],
+        "timestamp": 1504710000
+    },
+    {
+        "version": "0.14.1",
+        "changes": [
+            {
+                "note": "Fixed an issue with Artifact type not found",
+                "pr": 159
+            }
+        ],
+        "timestamp": 1504710000
+    },
+    {
+        "version": "0.14.0",
+        "changes": [
+            {
+                "note": "Added `zeroEx.exchange.throwLogErrorsAsErrors` method to public interface",
+                "pr": 157
+            },
+            {
+                "note": "Fixed an issue with overlapping async intervals in `zeroEx.awaitTransactionMinedAsync`",
+                "pr": 157
+            },
+            {
+                "note": "Fixed an issue with log decoder returning `BigNumber`s as `strings`",
+                "pr": 157
+            }
+        ],
+        "timestamp": 1504623600
+    },
+    {
+        "version": "0.13.0",
+        "changes": [
+            {
+                "note":
+                    "Made all the functions submitting transactions to the network to immediately return transaction hash",
+                "pr": 151
+            },
+            {
+                "note": "Added `zeroEx.awaitTransactionMinedAsync`",
+                "pr": 151
+            },
+            {
+                "note":
+                    "Added `TransactionReceiptWithDecodedLogs`, `LogWithDecodedArgs`, `DecodedLogArgs` to public types",
+                "pr": 151
+            },
+            {
+                "note": "Added signature validation to `validateFillOrderThrowIfInvalidAsync`",
+                "pr": 152
+            }
+        ],
+        "timestamp": 1504623600
+    },
+    {
+        "version": "0.12.1",
+        "changes": [
+            {
+                "note": "Added the support for web3@1.x.x provider",
+                "pr": 142
+            },
+            {
+                "note": "Added the optional `zeroExConfig`  parameter to the constructor of `ZeroEx`",
+                "pr": 139
+            },
+            {
+                "note": "Added the ability to specify `gasPrice` when instantiating `ZeroEx`",
+                "pr": 139
+            }
+        ],
+        "timestamp": 1504278000
+    },
+    {
+        "version": "0.11.0",
+        "changes": [
+            {
+                "note": "Added `zeroEx.token.setUnlimitedProxyAllowanceAsync`",
+                "pr": 137
+            },
+            {
+                "note": "Added `zeroEx.token.setUnlimitedAllowanceAsync`",
+                "pr": 137
+            },
+            {
+                "note": "Added `zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS`",
+                "pr": 137
+            }
+        ],
+        "timestamp": 1503500400
+    },
+    {
+        "version": "0.10.4",
+        "changes": [
+            {
+                "note": "Fixed a bug where checksummed addresses were being pulled from artifacts and not lower-cased.",
+                "pr": 135
+            }
+        ],
+        "timestamp": 1503500400
+    },
+    {
+        "version": "0.10.1",
+        "changes": [
+            {
+                "note": "Added `zeroEx.exchange.validateFillOrderThrowIfInvalidAsync`",
+                "pr": 128
+            },
+            {
+                "note": "Added `zeroEx.exchange.validateFillOrKillOrderThrowIfInvalidAsync`",
+                "pr": 128
+            },
+            {
+                "note": "Added `zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync`",
+                "pr": 128
+            },
+            {
+                "note": "Added `zeroEx.exchange.isRoundingErrorAsync`",
+                "pr": 128
+            },
+            {
+                "note": "Added `zeroEx.proxy.getContractAddressAsync`",
+                "pr": 130
+            },
+            {
+                "note": "Added `zeroEx.tokenRegistry.getTokenAddressesAsync`",
+                "pr": 132
+            },
+            {
+                "note": "Added `zeroEx.tokenRegistry.getTokenAddressBySymbolIfExistsAsync`",
+                "pr": 132
+            },
+            {
+                "note": "Added `zeroEx.tokenRegistry.getTokenAddressByNameIfExistsAsync`",
+                "pr": 132
+            },
+            {
+                "note": "Added `zeroEx.tokenRegistry.getTokenBySymbolIfExistsAsync`",
+                "pr": 132
+            },
+            {
+                "note": "Added `zeroEx.tokenRegistry.getTokenByNameIfExistsAsync`",
+                "pr": 132
+            },
+            {
+                "note": "Added clear error message when checksummed address is passed to a public method",
+                "pr": 124
+            },
+            {
+                "note": "Fixes the description of `shouldThrowOnInsufficientBalanceOrAllowance` in docs",
+                "pr": 127
+            }
+        ],
+        "timestamp": 1503500400
+    },
+    {
+        "version": "0.9.3",
+        "changes": [
+            {
+                "note": "Update contract artifacts to include latest Kovan and Mainnet deploys",
+                "pr": 118
+            }
+        ],
+        "timestamp": 1503327600
+    },
+    {
+        "version": "0.9.2",
+        "changes": [
+            {
+                "note": "*This version was unpublished because of a publishing issue.*"
+            },
+            {
+                "note": "Update contract artifacts to include latest Kovan and Mainnet deploys",
+                "pr": 118
+            }
+        ],
+        "timestamp": 1503241200
+    },
+    {
+        "version": "0.9.1",
+        "changes": [
+            {
+                "note": "Fixed the bug causing `zeroEx.token.getBalanceAsync()` to fail if no addresses available",
+                "pr": 120
+            }
+        ],
+        "timestamp": 1502809200
+    },
+    {
+        "version": "0.9.0",
+        "changes": [
+            {
+                "note": "Migrated to the new version of smart contracts",
+                "pr": 101
+            },
+            {
+                "note": "Removed the ability to call methods on multiple authorized Exchange smart contracts",
+                "pr": 106
+            },
+            {
+                "note": "Made `zeroEx.getOrderHashHex` a static method",
+                "pr": 107
+            },
+            {
+                "note": "Cached `net_version` requests and invalidate the cache on calls to `setProvider`",
+                "pr": 95
+            },
+            {
+                "note": "Renamed `zeroEx.exchange.batchCancelOrderAsync` to `zeroEx.exchange.batchCancelOrdersAsync`"
+            },
+            {
+                "note": "Renamed `zeroEx.exchange.batchFillOrderAsync` to `zeroEx.exchange.batchFillOrdersAsync`"
+            },
+            {
+                "note": "Updated to typescript v2.4",
+                "pr": 104
+            },
+            {
+                "note":
+                    "Fixed an issue with incorrect balance/allowance validation when ZRX is one of the tokens traded",
+                "pr": 109
+            }
+        ],
+        "timestamp": 1500994800
+    },
+    {
+        "version": "0.8.0",
+        "changes": [
+            {
+                "note":
+                    "Added the ability to call methods on different authorized versions of the Exchange smart contract",
+                "pr": 82
+            },
+            {
+                "note":
+                    "Updated contract artifacts to reflect latest changes to the smart contracts (0xproject/contracts#59)"
+            },
+            {
+                "note": "Added `zeroEx.proxy.isAuthorizedAsync` and `zeroEx.proxy.getAuthorizedAddressesAsync`",
+                "pr": 89
+            },
+            {
+                "note": "Added `zeroEx.token.subscribeAsync`",
+                "pr": 90
+            },
+            {
+                "note": "Made contract invalidation functions private",
+                "pr": 90
+            },
+            {
+                "note": "`zeroEx.token.invalidateContractInstancesAsync`"
+            },
+            {
+                "note": "`zeroEx.exchange.invalidateContractInstancesAsync`"
+            },
+            {
+                "note": "`zeroEx.proxy.invalidateContractInstance`"
+            },
+            {
+                "note": "`zeroEx.tokenRegistry.invalidateContractInstance`"
+            },
+            {
+                "note": "Fixed the bug where `zeroEx.setProviderAsync` didn't invalidate etherToken contract's instance"
+            }
+        ],
+        "timestamp": 1499094000
+    },
+    {
+        "version": "0.7.1",
+        "changes": [
+            {
+                "note":
+                    "Added the ability to convert Ether to wrapped Ether tokens and back via `zeroEx.etherToken.depostAsync` and `zeroEx.etherToken.withdrawAsync`",
+                "pr": 81
+            }
+        ],
+        "timestamp": 1498402800
+    },
+    {
+        "version": "0.7.0",
+        "changes": [
+            {
+                "note": "Added Kovan smart contract artifacts",
+                "pr": 78
+            },
+            {
+                "note": "Started returning fillAmount from `fillOrderAsync` and `fillUpToAsync`",
+                "pr": 72
+            },
+            {
+                "note": "Started returning cancelledAmount from `cancelOrderAsync`",
+                "pr": 72
+            },
+            {
+                "note":
+                    "Renamed type `LogCancelArgs` to `LogCancelContractEventArgs` and `LogFillArgs` to `LogFillContractEventArgs`"
+            }
+        ],
+        "timestamp": 1498057200
+    },
+    {
+        "version": "0.6.2",
+        "changes": [
+            {
+                "note": "Reduced bundle size"
+            },
+            {
+                "note": "Improved documentation"
+            }
+        ],
+        "timestamp": 1497970800
+    },
+    {
+        "version": "0.6.1",
+        "changes": [
+            {
+                "note": "Improved documentation"
+            }
+        ],
+        "timestamp": 1497798000
+    },
+    {
+        "version": "0.6.0",
+        "changes": [
+            {
+                "note": "Made `ZeroEx` class accept `Web3Provider` instance instead of `Web3` instance"
+            },
+            {
+                "note": "Added types for contract event arguments"
+            }
+        ],
+        "timestamp": 1497798000
+    },
+    {
+        "version": "0.5.2",
+        "changes": [
+            {
+                "note":
+                    "Fixed the bug in `postpublish` script that caused that only unminified UMD bundle was uploaded to release page"
+            }
+        ],
+        "timestamp": 1497452400
+    },
+    {
+        "version": "0.5.1",
+        "changes": [
+            {
+                "note": "Added `postpublish` script to publish to Github Releases with assets."
+            }
+        ],
+        "timestamp": 1497452400
+    }
+]

packages/0x.js/CHANGELOG.md

@@ -1,4 +1,47 @@
-# CHANGELOG
+<!--
+This file is auto-generated using the monorepo-scripts package. Don't edit directly.
+Edit the package's CHANGELOG.json file only.
+-->
+
+CHANGELOG
+
+## v0.36.1 - _April 18, 2018_
+
+    * Internal changes and refactoring
+    * Fix redundant expired order removal bug (#527)
+
+## v0.36.0 - _April 12, 2018_
+
+    * Moved Web3.Provider to `@0xproject/types:Provider` (#501)
+    * Add `zeroEx.exchange.getOrderStateAsync` to allow obtaining current OrderState for a signedOrder (#510)
+
+## 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 18, 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 8, 2018_
+
+    * Add missing EthersJs typescript typings as dependency
+
+## v0.33.0 - _March 4, 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 9, 2018_
 
@@ -20,10 +63,7 @@
 
 ## v0.31.0 - _January 30, 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)
+    * 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 29, 2018_
 
@@ -139,16 +179,16 @@
 ## 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 5, 2017_
@@ -174,9 +214,9 @@
 ## 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 8, 2017_
@@ -216,11 +256,11 @@
     * Added `zeroEx.token.setUnlimitedAllowanceAsync` (#137)
     * Added `zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS` (#137)
 
-## v0.10.4 - _Aug 24, 2017_
+## v0.10.4 - _August 24, 2017_
 
     * Fixed a bug where checksummed addresses were being pulled from artifacts and not lower-cased. (#135)
 
-## v0.10.1 - _Aug 24, 2017_
+## v0.10.1 - _August 24, 2017_
 
     * Added `zeroEx.exchange.validateFillOrderThrowIfInvalidAsync` (#128)
     * Added `zeroEx.exchange.validateFillOrKillOrderThrowIfInvalidAsync` (#128)
@@ -235,20 +275,20 @@
     * 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 - _Aug 22, 2017_
+## v0.9.3 - _August 22, 2017_
 
     * Update contract artifacts to include latest Kovan and Mainnet deploys (#118)
 
-## v0.9.2 - _Aug 21, 2017_
+## v0.9.2 - _August 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 - _Aug. 16, 2017_
+## v0.9.1 - _August 16, 2017_
 
     * Fixed the bug causing `zeroEx.token.getBalanceAsync()` to fail if no addresses available (#120)
 
-## v0.9.0 - _Jul. 26, 2017_
+## v0.9.0 - _July 26, 2017_
 
     * Migrated to the new version of smart contracts (#101)
     * Removed the ability to call methods on multiple authorized Exchange smart contracts (#106)
@@ -259,48 +299,48 @@
     * 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 - _Jul. 4, 2017_
+## v0.8.0 - _July 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 - _Jun. 26, 2017_
+## v0.7.1 - _June 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 - _Jun. 22, 2017_
+## v0.7.0 - _June 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 - _Jun. 21, 2017_
+## v0.6.2 - _June 21, 2017_
 
     * Reduced bundle size
     * Improved documentation
 
-## v0.6.1 - _Jun. 19, 2017_
+## v0.6.1 - _June 19, 2017_
 
     * Improved documentation
 
-## v0.6.0 - _Jun. 19, 2017_
+## v0.6.0 - _June 19, 2017_
 
     * Made `ZeroEx` class accept `Web3Provider` instance instead of `Web3` instance
     * Added types for contract event arguments
 
-## v0.5.2 - _Jun. 15, 2017_
+## v0.5.2 - _June 15, 2017_
 
     * Fixed the bug in `postpublish` script that caused that only unminified UMD bundle was uploaded to release page
 
-## v0.5.1 - _Jun. 15, 2017_
+## v0.5.1 - _June 15, 2017_
 
     * Added `postpublish` script to publish to Github Releases with assets.

packages/0x.js/README.md

@@ -1,5 +1,9 @@
 ## 0x.js
 
+A TypeScript/Javascript library for interacting with the 0x protocol.
+
+### Read the [Documentation](https://0xproject.com/docs/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.
@@ -18,11 +22,19 @@ npm install 0x.js --save
 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"],
+}
+```
+
 #### UMD:
 
 **Install**
 
-Download the UMD module from our [releases page](https://github.com/0xProject/0x.js/releases) and add it to your project.
+Download the UMD module from our [releases page](https://github.com/0xProject/0x-monorepo/releases) and add it to your project.
 
 **Import**
 
@@ -30,10 +42,66 @@ Download the UMD module from our [releases page](https://github.com/0xProject/0x
 <script type="text/javascript" src="0x.js"></script>
 ```
 
-## Documentation
+## Contributing
 
-Extensive documentation of 0x.js can be found on [our website][docs-url].
+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.
 
-[website-url]: https://0xproject.com/
-[whitepaper-url]: https://0xproject.com/pdfs/0x_white_paper.pdf
-[docs-url]: https://0xproject.com/docs/0xjs
+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
+
+If this is your **first** time building this package, you must first build **all** packages within the monorepo. This is because packages that depend on other packages located inside this monorepo are symlinked when run from **within** the monorepo. This allows you to make changes across multiple packages without first publishing dependent packages to NPM. To build all packages, run the following from the monorepo root directory:
+
+```bash
+yarn lerna:rebuild
+```
+
+Or continuously rebuild on change:
+
+```bash
+yarn dev
+```
+
+You can also build this specific package by running the following from within its directory:
+
+```bash
+yarn build
+```
+
+or continuously rebuild on change:
+
+```bash
+yarn build:watch
+```
+
+### Clean
+
+```bash
+yarn clean
+```
+
+### Lint
+
+```bash
+yarn lint
+```
+
+### Run Tests
+
+```bash
+yarn test
+```

packages/0x.js/contract_templates/partials/call.handlebars

@@ -1,15 +0,0 @@
-public {{this.name}} = {
-    async callAsync(
-    {{> typed_params inputs=inputs}}
-        defaultBlock?: Web3.BlockParam,
-    ): Promise<{{> return_type outputs=outputs}}> {
-        const self = this as {{contractName}}Contract;
-        const result = await promisify<{{> return_type outputs=outputs}}>(
-            self._web3ContractInstance.{{this.name}}.call,
-            self._web3ContractInstance,
-        )(
-            {{> params inputs=inputs}}
-        );
-        return result;
-    },
-};

packages/0x.js/contract_templates/partials/return_type.handlebars

@@ -1,6 +0,0 @@
-{{#singleReturnValue}}
-{{#returnType outputs.0.type}}{{/returnType}}
-{{/singleReturnValue}}
-{{^singleReturnValue}}
-[{{#each outputs}}{{#returnType type}}{{/returnType}}{{#unless @last}}, {{/unless}}{{/each}}]
-{{/singleReturnValue}}

packages/0x.js/contract_templates/partials/tx.handlebars

@@ -1,51 +0,0 @@
-public {{this.name}} = {
-    async sendTransactionAsync(
-    {{> typed_params inputs=inputs}}
-    {{#this.payable}}
-        txData: TxDataPayable = {},
-    {{/this.payable}}
-    {{^this.payable}}
-        txData: TxData = {},
-    {{/this.payable}}
-    ): Promise<string> {
-        const self = this as {{contractName}}Contract;
-        const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
-            txData,
-            self.{{this.name}}.estimateGasAsync.bind(
-                self,
-                {{> params inputs=inputs}}
-            ),
-        );
-        const txHash = await promisify<string>(
-            self._web3ContractInstance.{{this.name}}, self._web3ContractInstance,
-        )(
-            {{> params inputs=inputs}}
-            txDataWithDefaults,
-        );
-        return txHash;
-    },
-    async estimateGasAsync(
-    {{> typed_params inputs=inputs}}
-        txData: TxData = {},
-    ): Promise<number> {
-        const self = this as {{contractName}}Contract;
-        const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
-            txData,
-        );
-        const gas = await promisify<number>(
-            self._web3ContractInstance.{{this.name}}.estimateGas, self._web3ContractInstance,
-        )(
-            {{> params inputs=inputs}}
-            txDataWithDefaults,
-        );
-        return gas;
-    },
-    getABIEncodedTransactionData(
-    {{> typed_params inputs=inputs}}
-        txData: TxData = {},
-    ): string {
-        const self = this as {{contractName}}Contract;
-        const abiEncodedTransactionData = self._web3ContractInstance.{{this.name}}.getData();
-        return abiEncodedTransactionData;
-    },
-};

packages/0x.js/contract_templates/partials/typed_params.handlebars

@@ -1,3 +0,0 @@
-{{#each inputs}}
-    {{name}}: {{#parameterType type}}{{/parameterType}},
-{{/each}}

packages/0x.js/package.json

@@ -1,6 +1,6 @@
 {
     "name": "0x.js",
-    "version": "0.32.1",
+    "version": "0.36.1",
     "description": "A javascript library for interacting with the 0x protocol",
     "keywords": [
         "0x.js",
@@ -15,85 +15,109 @@
         "build:watch": "tsc -w",
         "prebuild": "run-s clean generate_contract_wrappers",
         "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 generated_docs/index.json $S3_URL --profile 0xproject --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers --content-type application/json",
-        "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",
+        "generate_contract_wrappers": "node ../abi-gen/lib/index.js --abis 'src/compact_artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry|DummyToken).json' --template ../contract_templates/contract.handlebars --partials '../contract_templates/partials/**/*.handlebars' --output src/contract_wrappers/generated --backend ethers && prettier --write 'src/contract_wrappers/generated/**.ts'",
         "lint": "tslint --project . 'src/**/*.ts' 'test/**/*.ts'",
-        "test:circleci": "run-s test:coverage report_test_coverage",
+        "test:circleci": "run-s test:coverage",
         "test": "run-s clean test:commonjs",
-        "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",
+        "test:coverage": "nyc npm run test --all && yarn coverage:report:lcov",
+        "coverage:report:lcov": "nyc report --reporter=text-lcov > coverage/lcov.info",
+        "update_artifacts": "for i in ${npm_package_config_contracts}; do copyfiles -u 4 ../migrations/src/artifacts/$i.json test/artifacts; done;",
+        "clean": "shx rm -rf _bundles lib test_temp scripts",
         "build:umd:prod": "NODE_ENV=production webpack",
-        "build:commonjs": "tsc && copyfiles -u 2 './src/artifacts/**/*.json' ./lib/src/artifacts;",
+        "build:commonjs": "tsc && yarn update_artifacts && copyfiles -u 2 './src/compact_artifacts/**/*.json' ./lib/src/compact_artifacts && copyfiles -u 3 './lib/src/monorepo_scripts/**/*' ./scripts",
         "test:commonjs": "run-s build:commonjs run_mocha",
-        "run_mocha": "mocha lib/test/**/*_test.js --timeout 10000 --bail --exit"
+        "run_mocha": "mocha lib/test/**/*_test.js --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"
+        "compact_artifacts": "Exchange DummyToken ZRXToken Token EtherToken TokenTransferProxy TokenRegistry",
+        "contracts": "Exchange DummyToken ZRXToken Token WETH9 TokenTransferProxy MultiSigWallet MultiSigWalletWithTimeLock MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress MaliciousToken TokenRegistry Arbitrage EtherDelta AccountLevels",
+        "postpublish": {
+            "assets": [
+                "packages/0x.js/_bundles/index.js",
+                "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.js"
+        "url": "https://github.com/0xProject/0x-monorepo"
     },
     "license": "Apache-2.0",
     "engines": {
         "node": ">=6.0.0"
     },
     "devDependencies": {
-        "@0xproject/abi-gen": "^0.2.0",
-        "@0xproject/dev-utils": "^0.0.11",
-        "@0xproject/tslint-config": "^0.4.7",
+        "@0xproject/deployer": "^0.4.1",
+        "@0xproject/dev-utils": "^0.3.6",
+        "@0xproject/monorepo-scripts": "^0.1.18",
+        "@0xproject/subproviders": "^0.9.0",
+        "@0xproject/tslint-config": "^0.4.16",
         "@types/bintrees": "^1.0.2",
-        "@types/jsonschema": "^1.1.1",
-        "@types/lodash": "^4.14.86",
+        "@types/lodash": "4.14.104",
         "@types/mocha": "^2.2.42",
         "@types/node": "^8.0.53",
+        "@types/request": "2.47.0",
         "@types/sinon": "^2.2.2",
         "@types/uuid": "^3.4.2",
         "awesome-typescript-loader": "^3.1.3",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
-        "chai-as-promised-typescript-typings": "^0.0.8",
         "chai-bignumber": "^2.0.1",
-        "chai-typescript-typings": "^0.0.2",
         "copyfiles": "^1.2.0",
-        "coveralls": "^3.0.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": "~0.8.0",
-        "types-bn": "^0.0.1",
+        "typedoc": "0xProject/typedoc",
         "typescript": "2.7.1",
         "web3-provider-engine": "^13.0.1",
-        "web3-typescript-typings": "^0.9.9",
         "webpack": "^3.1.0"
     },
     "dependencies": {
-        "@0xproject/assert": "^0.0.17",
-        "@0xproject/json-schemas": "^0.7.9",
-        "@0xproject/types": "^0.2.0",
-        "@0xproject/utils": "^0.3.1",
-        "@0xproject/web3-wrapper": "^0.1.11",
+        "@0xproject/assert": "^0.2.7",
+        "@0xproject/base-contract": "^0.2.1",
+        "@0xproject/json-schemas": "^0.7.21",
+        "@0xproject/types": "^0.6.1",
+        "@0xproject/typescript-typings": "^0.2.0",
+        "@0xproject/utils": "^0.5.2",
+        "@0xproject/web3-wrapper": "^0.6.1",
         "bintrees": "^1.0.2",
         "bn.js": "^4.11.8",
         "ethereumjs-abi": "^0.6.4",
         "ethereumjs-blockstream": "^2.0.6",
         "ethereumjs-util": "^5.1.1",
+        "ethers-contracts": "^2.2.1",
         "js-sha3": "^0.7.0",
         "lodash": "^4.17.4",
         "uuid": "^3.1.0",
         "web3": "^0.20.0"
+    },
+    "optionalDependencies": {
+        "@0xproject/migrations": "^0.0.1"
+    },
+    "publishConfig": {
+        "access": "public"
     }
 }

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

@@ -1,40 +0,0 @@
-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.publishReleaseNotesAsync(tag, releaseName, assets);
-    })
-    .then(function(release) {
-        console.log('POSTPUBLISH: Release successful, generating docs...');
-        const jsonFilePath = __dirname + '/../' + postpublish_utils.generatedDocsDirectoryName + '/index.json';
-        return execAsync('JSON_FILE_PATH=' + jsonFilePath + ' 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/src/0x.ts

@@ -1,5 +1,5 @@
 import { schemas, SchemaValidator } from '@0xproject/json-schemas';
-import { TransactionReceiptWithDecodedLogs } from '@0xproject/types';
+import { ECSignature, Order, Provider, SignedOrder, TransactionReceiptWithDecodedLogs } from '@0xproject/types';
 import { AbiDecoder, BigNumber, intervalUtils } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as ethUtil from 'ethereumjs-util';
@@ -13,7 +13,9 @@ import { TokenTransferProxyWrapper } from './contract_wrappers/token_transfer_pr
 import { TokenWrapper } from './contract_wrappers/token_wrapper';
 import { OrderStateWatcher } from './order_watcher/order_state_watcher';
 import { zeroExConfigSchema } from './schemas/zero_ex_config_schema';
-import { ECSignature, Order, SignedOrder, Web3Provider, ZeroExConfig, ZeroExError } from './types';
+import { zeroExPrivateNetworkConfigSchema } from './schemas/zero_ex_private_network_config_schema';
+import { zeroExPublicNetworkConfigSchema } from './schemas/zero_ex_public_network_config_schema';
+import { OrderStateWatcherConfig, ZeroExConfig, ZeroExError } from './types';
 import { assert } from './utils/assert';
 import { constants } from './utils/constants';
 import { decorators } from './utils/decorators';
@@ -55,13 +57,7 @@ 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.
@@ -74,13 +70,14 @@ 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, signerAddress);
+        const isValidSignature = signatureUtils.isValidSignature(data, signature, normalizedSignerAddress);
         return isValidSignature;
     }
     /**
      * Generates a pseudo-random 256-bit salt.
-     * The salt can be included in an 0x order, ensuring that the order generates a unique orderHash
+     * The salt can be included in a 0x order, ensuring that the order generates a unique orderHash
      * and will not collide with other outstanding orders that are identical in all other parameters.
      * @return  A pseudo-random 256-bit number that can be used as a salt.
      */
@@ -118,10 +115,8 @@ export class ZeroEx {
     public static toUnitAmount(amount: BigNumber, decimals: number): BigNumber {
         assert.isValidBaseUnitAmount('amount', amount);
         assert.isNumber('decimals', decimals);
-
-        const aUnit = new BigNumber(10).pow(decimals);
-        const unit = amount.div(aUnit);
-        return unit;
+        const unitAmount = Web3Wrapper.toUnitAmount(amount, decimals);
+        return unitAmount;
     }
     /**
      * A baseUnit is defined as the smallest denomination of a token. An amount expressed in baseUnits
@@ -134,13 +129,7 @@ export class ZeroEx {
     public static toBaseUnitAmount(amount: BigNumber, decimals: number): BigNumber {
         assert.isBigNumber('amount', amount);
         assert.isNumber('decimals', decimals);
-
-        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`);
-        }
+        const baseUnitAmount = Web3Wrapper.toBaseUnitAmount(amount, decimals);
         return baseUnitAmount;
     }
     /**
@@ -156,31 +145,35 @@ export class ZeroEx {
     }
     /**
      * Instantiates a new ZeroEx instance that provides the public interface to the 0x.js library.
-     * @param   provider    The Web3.js Provider instance you would like the 0x.js library to use for interacting with
+     * @param   provider    The Provider instance you would like the 0x.js library to use for interacting with
      *                      the Ethereum network.
      * @param   config      The configuration object. Look up the type for the description.
      * @return  An instance of the 0x.js ZeroEx class.
      */
-    constructor(provider: Web3Provider, config: ZeroExConfig) {
+    constructor(provider: Provider, config: ZeroExConfig) {
         assert.isWeb3Provider('provider', provider);
-        assert.doesConformToSchema('config', config, zeroExConfigSchema);
+        assert.doesConformToSchema('config', config, zeroExConfigSchema, [
+            zeroExPrivateNetworkConfigSchema,
+            zeroExPublicNetworkConfigSchema,
+        ]);
         const artifactJSONs = _.values(artifacts);
         const abiArrays = _.map(artifactJSONs, artifact => artifact.abi);
-        this._abiDecoder = new AbiDecoder(abiArrays);
         const defaults = {
             gasPrice: config.gasPrice,
         };
         this._web3Wrapper = new Web3Wrapper(provider, defaults);
+        _.forEach(abiArrays, abi => {
+            this._web3Wrapper.abiDecoder.addABI(abi);
+        });
         this.proxy = new TokenTransferProxyWrapper(
             this._web3Wrapper,
             config.networkId,
             config.tokenTransferProxyContractAddress,
         );
-        this.token = new TokenWrapper(this._web3Wrapper, config.networkId, this._abiDecoder, this.proxy);
+        this.token = new TokenWrapper(this._web3Wrapper, config.networkId, this.proxy);
         this.exchange = new ExchangeWrapper(
             this._web3Wrapper,
             config.networkId,
-            this._abiDecoder,
             this.token,
             config.exchangeContractAddress,
             config.zrxContractAddress,
@@ -190,14 +183,7 @@ export class ZeroEx {
             config.networkId,
             config.tokenRegistryContractAddress,
         );
-        this.etherToken = new EtherTokenWrapper(this._web3Wrapper, config.networkId, this._abiDecoder, this.token);
-        this.orderStateWatcher = new OrderStateWatcher(
-            this._web3Wrapper,
-            this._abiDecoder,
-            this.token,
-            this.exchange,
-            config.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
@@ -205,7 +191,7 @@ export class ZeroEx {
      * @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 setProvider(provider: Provider, networkId: number): void {
         this._web3Wrapper.setProvider(provider);
         (this.exchange as any)._invalidateContractInstances();
         (this.exchange as any)._setNetworkId(networkId);
@@ -231,7 +217,7 @@ export class ZeroEx {
      * This method currently supports TestRPC, Geth and Parity above and below V1.6.6
      * @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.
+     *          must be available via the 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
@@ -245,6 +231,7 @@ export class ZeroEx {
     ): Promise<ECSignature> {
         assert.isHexString('orderHash', orderHash);
         await assert.isSenderAddressAsync('signerAddress', signerAddress, this._web3Wrapper);
+        const normalizedSignerAddress = signerAddress.toLowerCase();
 
         let msgHashHex = orderHash;
         if (shouldAddPersonalMessagePrefix) {
@@ -253,7 +240,7 @@ export class ZeroEx {
             msgHashHex = ethUtil.bufferToHex(msgHashBuff);
         }
 
-        const signature = await this._web3Wrapper.signTransactionAsync(signerAddress, msgHashHex);
+        const signature = await this._web3Wrapper.signMessageAsync(normalizedSignerAddress, msgHashHex);
 
         // HACK: There is no consensus on whether the signatureHex string should be formatted as
         // v + r + s OR r + s + v, and different clients (even different versions of the same client)
@@ -262,7 +249,7 @@ export class ZeroEx {
         const validVParamValues = [27, 28];
         const ecSignatureVRS = signatureUtils.parseSignatureHexAsVRS(signature);
         if (_.includes(validVParamValues, ecSignatureVRS.v)) {
-            const isValidVRSSignature = ZeroEx.isValidSignature(orderHash, ecSignatureVRS, signerAddress);
+            const isValidVRSSignature = ZeroEx.isValidSignature(orderHash, ecSignatureVRS, normalizedSignerAddress);
             if (isValidVRSSignature) {
                 return ecSignatureVRS;
             }
@@ -270,7 +257,7 @@ export class ZeroEx {
 
         const ecSignatureRSV = signatureUtils.parseSignatureHexAsRSV(signature);
         if (_.includes(validVParamValues, ecSignatureRSV.v)) {
-            const isValidRSVSignature = ZeroEx.isValidSignature(orderHash, ecSignatureRSV, signerAddress);
+            const isValidRSVSignature = ZeroEx.isValidSignature(orderHash, ecSignatureRSV, normalizedSignerAddress);
             if (isValidRSVSignature) {
                 return ecSignatureRSV;
             }
@@ -290,44 +277,21 @@ export class ZeroEx {
         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,
-                    (err: Error) => {
-                        intervalUtils.clearAsyncExcludingInterval(intervalId);
-                        reject(err);
-                    },
-                );
-            },
+        const transactionReceiptWithDecodedLogs = await this._web3Wrapper.awaitTransactionMinedAsync(
+            txHash,
+            pollingIntervalMs,
+            timeoutMs,
         );
-        const txReceipt = await txReceiptPromise;
-        return txReceipt;
+        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);
     }
     /*
      * HACK: `TokenWrapper` needs a token transfer proxy address. `TokenTransferProxy` address is fetched from

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

@@ -0,0 +1,6 @@
+import { BigNumber } from '@0xproject/utils';
+
+export abstract class BalanceAndProxyAllowanceFetcher {
+    public abstract async getBalanceAsync(tokenAddress: string, userAddress: string): Promise<BigNumber>;
+    public abstract async getProxyAllowanceAsync(tokenAddress: string, userAddress: string): Promise<BigNumber>;
+}

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

@@ -0,0 +1,6 @@
+import { BigNumber } from '@0xproject/utils';
+
+export abstract class OrderFilledCancelledFetcher {
+    public abstract async getFilledTakerAmountAsync(orderHash: string): Promise<BigNumber>;
+    public abstract async getCancelledTakerAmountAsync(orderHash: string): Promise<BigNumber>;
+}

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

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

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

@@ -1,4 +1,4 @@
-import { BlockParamLiteral, LogWithDecodedArgs, RawLog } from '@0xproject/types';
+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';
@@ -32,19 +32,17 @@ const CONTRACT_NAME_TO_NOT_FOUND_ERROR: {
 export class ContractWrapper {
     protected _web3Wrapper: Web3Wrapper;
     protected _networkId: number;
-    private _abiDecoder?: AbiDecoder;
     private _blockAndLogStreamerIfExists?: BlockAndLogStreamer;
     private _blockAndLogStreamIntervalIfExists?: NodeJS.Timer;
-    private _filters: { [filterToken: string]: Web3.FilterObject };
+    private _filters: { [filterToken: string]: FilterObject };
     private _filterCallbacks: {
         [filterToken: string]: EventCallback<ContractEventArgs>;
     };
     private _onLogAddedSubscriptionToken: string | undefined;
     private _onLogRemovedSubscriptionToken: string | undefined;
-    constructor(web3Wrapper: Web3Wrapper, networkId: number, abiDecoder?: AbiDecoder) {
+    constructor(web3Wrapper: Web3Wrapper, networkId: number) {
         this._web3Wrapper = web3Wrapper;
         this._networkId = networkId;
-        this._abiDecoder = abiDecoder;
         this._filters = {};
         this._filterCallbacks = {};
         this._blockAndLogStreamerIfExists = undefined;
@@ -75,7 +73,7 @@ export class ContractWrapper {
         address: string,
         eventName: ContractEvents,
         indexFilterValues: IndexedFilterValues,
-        abi: Web3.ContractAbi,
+        abi: ContractAbi,
         callback: EventCallback<ArgsType>,
     ): string {
         const filter = filterUtils.getFilter(address, eventName, indexFilterValues, abi);
@@ -92,7 +90,7 @@ export class ContractWrapper {
         eventName: ContractEvents,
         blockRange: BlockRange,
         indexFilterValues: IndexedFilterValues,
-        abi: Web3.ContractAbi,
+        abi: ContractAbi,
     ): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
         const filter = filterUtils.getFilter(address, eventName, indexFilterValues, abi, blockRange);
         const logs = await this._web3Wrapper.getLogsAsync(filter);
@@ -100,18 +98,18 @@ export class ContractWrapper {
         return logsWithDecodedArguments;
     }
     protected _tryToDecodeLogOrNoop<ArgsType extends ContractEventArgs>(
-        log: Web3.LogEntry,
+        log: LogEntry,
     ): LogWithDecodedArgs<ArgsType> | RawLog {
-        if (_.isUndefined(this._abiDecoder)) {
+        if (_.isUndefined(this._web3Wrapper.abiDecoder)) {
             throw new Error(InternalZeroExError.NoAbiDecoder);
         }
-        const logWithDecodedArgs = this._abiDecoder.tryToDecodeLogOrNoop(log);
+        const logWithDecodedArgs = this._web3Wrapper.abiDecoder.tryToDecodeLogOrNoop(log);
         return logWithDecodedArgs;
     }
-    protected async _instantiateContractIfExistsAsync(
+    protected async _getContractAbiAndAddressFromArtifactsAsync(
         artifact: Artifact,
         addressIfExists?: string,
-    ): Promise<Web3.ContractInstance> {
+    ): Promise<[ContractAbi, string]> {
         let contractAddress: string;
         if (_.isUndefined(addressIfExists)) {
             if (_.isUndefined(artifact.networks[this._networkId])) {
@@ -125,8 +123,8 @@ export class ContractWrapper {
         if (!doesContractExist) {
             throw new Error(CONTRACT_NAME_TO_NOT_FOUND_ERROR[artifact.contract_name]);
         }
-        const contractInstance = this._web3Wrapper.getContractInstance(artifact.abi, contractAddress);
-        return contractInstance;
+        const abiAndAddress: [ContractAbi, string] = [artifact.abi, contractAddress];
+        return abiAndAddress;
     }
     protected _getContractAddress(artifact: Artifact, addressIfExists?: string): string {
         if (_.isUndefined(addressIfExists)) {
@@ -139,8 +137,8 @@ export class ContractWrapper {
             return addressIfExists;
         }
     }
-    private _onLogStateChanged<ArgsType extends ContractEventArgs>(isRemoved: boolean, log: Web3.LogEntry): void {
-        _.forEach(this._filters, (filter: Web3.FilterObject, filterToken: string) => {
+    private _onLogStateChanged<ArgsType extends ContractEventArgs>(isRemoved: boolean, log: LogEntry): void {
+        _.forEach(this._filters, (filter: FilterObject, filterToken: string) => {
             if (filterUtils.matchesFilter(log, filter)) {
                 const decodedLog = this._tryToDecodeLogOrNoop(log) as LogWithDecodedArgs<ArgsType>;
                 const logEvent = {

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

@@ -21,8 +21,8 @@ export class EtherTokenWrapper extends ContractWrapper {
         [address: string]: EtherTokenContract;
     } = {};
     private _tokenWrapper: TokenWrapper;
-    constructor(web3Wrapper: Web3Wrapper, networkId: number, abiDecoder: AbiDecoder, tokenWrapper: TokenWrapper) {
-        super(web3Wrapper, networkId, abiDecoder);
+    constructor(web3Wrapper: Web3Wrapper, networkId: number, tokenWrapper: TokenWrapper) {
+        super(web3Wrapper, networkId);
         this._tokenWrapper = tokenWrapper;
     }
     /**
@@ -41,15 +41,18 @@ export class EtherTokenWrapper extends ContractWrapper {
         depositor: string,
         txOpts: TransactionOpts = {},
     ): Promise<string> {
+        assert.isETHAddressHex('etherTokenAddress', etherTokenAddress);
         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(depositor);
+        const ethBalanceInWei = await this._web3Wrapper.getBalanceInWeiAsync(normalizedDepositorAddress);
         assert.assert(ethBalanceInWei.gte(amountInWei), ZeroExError.InsufficientEthBalanceForDeposit);
 
-        const wethContract = await this._getEtherTokenContractAsync(etherTokenAddress);
+        const wethContract = await this._getEtherTokenContractAsync(normalizedEtherTokenAddress);
         const txHash = await wethContract.deposit.sendTransactionAsync({
-            from: depositor,
+            from: normalizedDepositorAddress,
             value: amountInWei,
             gas: txOpts.gasLimit,
             gasPrice: txOpts.gasPrice,
@@ -61,7 +64,7 @@ export class EtherTokenWrapper extends ContractWrapper {
      * 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 withdrawl.
+     * @param   withdrawer   The hex encoded user Ethereum address that would like to make the withdrawal.
      * @param   txOpts       Transaction parameters.
      * @return Transaction hash.
      */
@@ -72,14 +75,20 @@ export class EtherTokenWrapper extends ContractWrapper {
         txOpts: TransactionOpts = {},
     ): 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(etherTokenAddress, withdrawer);
+        const WETHBalanceInBaseUnits = await this._tokenWrapper.getBalanceAsync(
+            normalizedEtherTokenAddress,
+            normalizedWithdrawerAddress,
+        );
         assert.assert(WETHBalanceInBaseUnits.gte(amountInWei), ZeroExError.InsufficientWEthBalanceForWithdrawal);
 
-        const wethContract = await this._getEtherTokenContractAsync(etherTokenAddress);
+        const wethContract = await this._getEtherTokenContractAsync(normalizedEtherTokenAddress);
         const txHash = await wethContract.withdraw.sendTransactionAsync(amountInWei, {
-            from: withdrawer,
+            from: normalizedWithdrawerAddress,
             gas: txOpts.gasLimit,
             gasPrice: txOpts.gasPrice,
         });
@@ -87,7 +96,7 @@ export class EtherTokenWrapper extends ContractWrapper {
     }
     /**
      * Gets historical logs without creating a subscription
-     * @param   etherTokenAddress   An address of the ether token that emmited the logs.
+     * @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
@@ -101,11 +110,12 @@ export class EtherTokenWrapper extends ContractWrapper {
         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>(
-            etherTokenAddress,
+            normalizedEtherTokenAddress,
             eventName,
             blockRange,
             indexFilterValues,
@@ -129,11 +139,12 @@ export class EtherTokenWrapper extends ContractWrapper {
         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>(
-            etherTokenAddress,
+            normalizedEtherTokenAddress,
             eventName,
             indexFilterValues,
             artifacts.EtherTokenArtifact.abi,
@@ -151,7 +162,7 @@ export class EtherTokenWrapper extends ContractWrapper {
     /**
      * Cancels all existing subscriptions
      */
-    public _unsubscribeAll(): void {
+    public unsubscribeAll(): void {
         super._unsubscribeAll();
     }
     /**
@@ -168,7 +179,7 @@ export class EtherTokenWrapper extends ContractWrapper {
         return contractAddressIfExists;
     }
     private _invalidateContractInstance(): void {
-        this._unsubscribeAll();
+        this.unsubscribeAll();
         this._etherTokenContractsByAddress = {};
     }
     private async _getEtherTokenContractAsync(etherTokenAddress: string): Promise<EtherTokenContract> {
@@ -176,11 +187,16 @@ export class EtherTokenWrapper extends ContractWrapper {
         if (!_.isUndefined(etherTokenContract)) {
             return etherTokenContract;
         }
-        const web3ContractInstance = await this._instantiateContractIfExistsAsync(
+        const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
             artifacts.EtherTokenArtifact,
             etherTokenAddress,
         );
-        const contractInstance = new EtherTokenContract(web3ContractInstance, this._web3Wrapper.getContractDefaults());
+        const contractInstance = new EtherTokenContract(
+            abi,
+            address,
+            this._web3Wrapper.getProvider(),
+            this._web3Wrapper.getContractDefaults(),
+        );
         etherTokenContract = contractInstance;
         this._etherTokenContractsByAddress[etherTokenAddress] = etherTokenContract;
         return etherTokenContract;

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

@@ -1,31 +1,39 @@
 import { schemas } from '@0xproject/json-schemas';
-import { BlockParamLiteral, DecodedLogArgs, LogWithDecodedArgs } from '@0xproject/types';
+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 * as Web3 from 'web3';
 
 import { artifacts } from '../artifacts';
+import { SimpleBalanceAndProxyAllowanceFetcher } from '../fetchers/simple_balance_and_proxy_allowance_fetcher';
+import { SimpleOrderFilledCancelledFetcher } from '../fetchers/simple_order_filled_cancelled_fetcher';
 import {
     BlockRange,
-    ECSignature,
     EventCallback,
     ExchangeContractErrCodes,
     ExchangeContractErrs,
     IndexedFilterValues,
     MethodOpts,
-    Order,
     OrderAddresses,
     OrderCancellationRequest,
     OrderFillRequest,
+    OrderState,
     OrderTransactionOpts,
     OrderValues,
-    SignedOrder,
     ValidateOrderFillableOpts,
 } from '../types';
 import { assert } from '../utils/assert';
 import { decorators } from '../utils/decorators';
 import { ExchangeTransferSimulator } from '../utils/exchange_transfer_simulator';
+import { OrderStateUtils } from '../utils/order_state_utils';
 import { OrderValidationUtils } from '../utils/order_validation_utils';
 import { utils } from '../utils/utils';
 
@@ -37,7 +45,6 @@ import {
     LogErrorContractEventArgs,
 } from './generated/exchange';
 import { TokenWrapper } from './token_wrapper';
-
 const SHOULD_VALIDATE_BY_DEFAULT = true;
 
 interface ExchangeContractErrCodesToMsgs {
@@ -83,12 +90,11 @@ export class ExchangeWrapper extends ContractWrapper {
     constructor(
         web3Wrapper: Web3Wrapper,
         networkId: number,
-        abiDecoder: AbiDecoder,
         tokenWrapper: TokenWrapper,
         contractAddressIfExists?: string,
         zrxContractAddressIfExists?: string,
     ) {
-        super(web3Wrapper, networkId, abiDecoder);
+        super(web3Wrapper, networkId);
         this._tokenWrapper = tokenWrapper;
         this._orderValidationUtils = new OrderValidationUtils(this);
         this._contractAddressIfExists = contractAddressIfExists;
@@ -108,8 +114,10 @@ export class ExchangeWrapper extends ContractWrapper {
 
         const exchangeContract = await this._getExchangeContractAsync();
         const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
+        const txData = {};
         let unavailableTakerTokenAmount = await exchangeContract.getUnavailableTakerTokenAmount.callAsync(
             orderHash,
+            txData,
             defaultBlock,
         );
         // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
@@ -127,7 +135,8 @@ export class ExchangeWrapper extends ContractWrapper {
 
         const exchangeContract = await this._getExchangeContractAsync();
         const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
-        let fillAmountInBaseUnits = await exchangeContract.filled.callAsync(orderHash, defaultBlock);
+        const txData = {};
+        let fillAmountInBaseUnits = await exchangeContract.filled.callAsync(orderHash, txData, defaultBlock);
         // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
         fillAmountInBaseUnits = new BigNumber(fillAmountInBaseUnits);
         return fillAmountInBaseUnits;
@@ -144,7 +153,8 @@ export class ExchangeWrapper extends ContractWrapper {
 
         const exchangeContract = await this._getExchangeContractAsync();
         const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
-        let cancelledAmountInBaseUnits = await exchangeContract.cancelled.callAsync(orderHash, defaultBlock);
+        const txData = {};
+        let cancelledAmountInBaseUnits = await exchangeContract.cancelled.callAsync(orderHash, txData, defaultBlock);
         // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
         cancelledAmountInBaseUnits = new BigNumber(cancelledAmountInBaseUnits);
         return cancelledAmountInBaseUnits;
@@ -163,7 +173,7 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   shouldThrowOnInsufficientBalanceOrAllowance Whether or not you wish for the contract call to throw
      *                                                      if upon execution the tokens cannot be transferred.
      * @param   takerAddress                                The user Ethereum address who would like to fill this order.
-     *                                                      Must be available via the supplied Web3.Provider
+     *                                                      Must be available via the supplied Provider
      *                                                      passed to 0x.js.
      * @param   orderTransactionOpts                        Optional arguments this method accepts.
      * @return  Transaction hash.
@@ -180,6 +190,7 @@ export class ExchangeWrapper extends ContractWrapper {
         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)
@@ -192,7 +203,7 @@ export class ExchangeWrapper extends ContractWrapper {
                 exchangeTradeEmulator,
                 signedOrder,
                 fillTakerTokenAmount,
-                takerAddress,
+                normalizedTakerAddress,
                 zrxTokenAddress,
             );
         }
@@ -208,7 +219,7 @@ export class ExchangeWrapper extends ContractWrapper {
             signedOrder.ecSignature.r,
             signedOrder.ecSignature.s,
             {
-                from: takerAddress,
+                from: normalizedTakerAddress,
                 gas: orderTransactionOpts.gasLimit,
                 gasPrice: orderTransactionOpts.gasPrice,
             },
@@ -227,7 +238,7 @@ export class ExchangeWrapper extends ContractWrapper {
      *                                                      If set to false, the call will continue to fill subsequent
      *                                                      signedOrders even when some cannot be filled.
      * @param   takerAddress                                The user Ethereum address who would like to fill these
-     *                                                      orders. Must be available via the supplied Web3.Provider
+     *                                                      orders. Must be available via the supplied Provider
      *                                                      passed to 0x.js.
      * @param   orderTransactionOpts                        Optional arguments this method accepts.
      * @return  Transaction hash.
@@ -254,6 +265,7 @@ export class ExchangeWrapper extends ContractWrapper {
         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
@@ -267,10 +279,13 @@ export class ExchangeWrapper extends ContractWrapper {
                     exchangeTradeEmulator,
                     signedOrder,
                     fillTakerTokenAmount.minus(filledTakerTokenAmount),
-                    takerAddress,
+                    normalizedTakerAddress,
                     zrxTokenAddress,
                 );
                 filledTakerTokenAmount = filledTakerTokenAmount.plus(singleFilledTakerTokenAmount);
+                if (filledTakerTokenAmount.eq(fillTakerTokenAmount)) {
+                    break;
+                }
             }
         }
 
@@ -301,7 +316,7 @@ export class ExchangeWrapper extends ContractWrapper {
             rArray,
             sArray,
             {
-                from: takerAddress,
+                from: normalizedTakerAddress,
                 gas: orderTransactionOpts.gasLimit,
                 gasPrice: orderTransactionOpts.gasPrice,
             },
@@ -323,7 +338,7 @@ export class ExchangeWrapper extends ContractWrapper {
      *                                                          cannot be filled.
      * @param   takerAddress                                    The user Ethereum address who would like to fill
      *                                                          these orders. Must be available via the supplied
-     *                                                          Web3.Provider passed to 0x.js.
+     *                                                          Provider passed to 0x.js.
      * @param   orderTransactionOpts                            Optional arguments this method accepts.
      * @return  Transaction hash.
      */
@@ -345,6 +360,7 @@ export class ExchangeWrapper extends ContractWrapper {
         );
         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;
@@ -356,7 +372,7 @@ export class ExchangeWrapper extends ContractWrapper {
                     exchangeTradeEmulator,
                     orderFillRequest.signedOrder,
                     orderFillRequest.takerTokenFillAmount,
-                    takerAddress,
+                    normalizedTakerAddress,
                     zrxTokenAddress,
                 );
             }
@@ -389,7 +405,7 @@ export class ExchangeWrapper extends ContractWrapper {
             rArray,
             sArray,
             {
-                from: takerAddress,
+                from: normalizedTakerAddress,
                 gas: orderTransactionOpts.gasLimit,
                 gasPrice: orderTransactionOpts.gasPrice,
             },
@@ -403,7 +419,7 @@ export class ExchangeWrapper extends ContractWrapper {
      *                                  signedOrder you wish to fill.
      * @param   fillTakerTokenAmount    The total amount of the takerTokens you would like to fill.
      * @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.
+     *                                  Must be available via the supplied Provider passed to 0x.js.
      * @param   orderTransactionOpts    Optional arguments this method accepts.
      * @return  Transaction hash.
      */
@@ -417,6 +433,7 @@ export class ExchangeWrapper extends ContractWrapper {
         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();
 
@@ -430,7 +447,7 @@ export class ExchangeWrapper extends ContractWrapper {
                 exchangeTradeEmulator,
                 signedOrder,
                 fillTakerTokenAmount,
-                takerAddress,
+                normalizedTakerAddress,
                 zrxTokenAddress,
             );
         }
@@ -444,7 +461,7 @@ export class ExchangeWrapper extends ContractWrapper {
             signedOrder.ecSignature.r,
             signedOrder.ecSignature.s,
             {
-                from: takerAddress,
+                from: normalizedTakerAddress,
                 gas: orderTransactionOpts.gasLimit,
                 gasPrice: orderTransactionOpts.gasPrice,
             },
@@ -456,7 +473,7 @@ export class ExchangeWrapper extends ContractWrapper {
      * filled (each to the specified fillAmount) or aborted.
      * @param   orderFillRequests           An array of objects that conform to the OrderFillRequest interface.
      * @param   takerAddress                The user Ethereum address who would like to fill there orders.
-     *                                      Must be available via the supplied Web3.Provider passed to 0x.js.
+     *                                      Must be available via the supplied Provider passed to 0x.js.
      * @param   orderTransactionOpts        Optional arguments this method accepts.
      * @return  Transaction hash.
      */
@@ -476,6 +493,7 @@ export class ExchangeWrapper extends ContractWrapper {
             ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
         );
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
+        const normalizedTakerAddress = takerAddress.toLowerCase();
         if (_.isEmpty(orderFillRequests)) {
             throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
         }
@@ -492,7 +510,7 @@ export class ExchangeWrapper extends ContractWrapper {
                     exchangeTradeEmulator,
                     orderFillRequest.signedOrder,
                     orderFillRequest.takerTokenFillAmount,
-                    takerAddress,
+                    normalizedTakerAddress,
                     zrxTokenAddress,
                 );
             }
@@ -520,7 +538,7 @@ export class ExchangeWrapper extends ContractWrapper {
             rParams,
             sParams,
             {
-                from: takerAddress,
+                from: normalizedTakerAddress,
                 gas: orderTransactionOpts.gasLimit,
                 gasPrice: orderTransactionOpts.gasPrice,
             },
@@ -544,6 +562,7 @@ export class ExchangeWrapper extends ContractWrapper {
         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();
 
@@ -566,7 +585,7 @@ export class ExchangeWrapper extends ContractWrapper {
             orderValues,
             cancelTakerTokenAmount,
             {
-                from: order.maker,
+                from: normalizedMakerAddress,
                 gas: orderTransactionOpts.gasLimit,
                 gasPrice: orderTransactionOpts.gasPrice,
             },
@@ -603,6 +622,8 @@ export class ExchangeWrapper extends ContractWrapper {
         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;
@@ -636,7 +657,7 @@ export class ExchangeWrapper extends ContractWrapper {
             orderValues,
             cancelTakerTokenAmounts,
             {
-                from: maker,
+                from: normalizedMakerAddress,
                 gas: orderTransactionOpts.gasLimit,
                 gasPrice: orderTransactionOpts.gasPrice,
             },
@@ -679,7 +700,7 @@ export class ExchangeWrapper extends ContractWrapper {
     /**
      * Cancels all existing subscriptions
      */
-    public _unsubscribeAll(): void {
+    public unsubscribeAll(): void {
         super._unsubscribeAll();
     }
     /**
@@ -747,7 +768,7 @@ export class ExchangeWrapper extends ContractWrapper {
      *                                  signedOrder you wish to fill.
      * @param   fillTakerTokenAmount    The total amount of the takerTokens you would like to fill.
      * @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.
+     *                                  Must be available via the supplied Provider passed to 0x.js.
      */
     public async validateFillOrderThrowIfInvalidAsync(
         signedOrder: SignedOrder,
@@ -757,13 +778,14 @@ export class ExchangeWrapper extends ContractWrapper {
         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);
         await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
             exchangeTradeEmulator,
             signedOrder,
             fillTakerTokenAmount,
-            takerAddress,
+            normalizedTakerAddress,
             zrxTokenAddress,
         );
     }
@@ -793,7 +815,7 @@ export class ExchangeWrapper extends ContractWrapper {
      *                                  signedOrder you wish to fill.
      * @param   fillTakerTokenAmount    The total amount of the takerTokens you would like to fill.
      * @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.
+     *                                  Must be available via the supplied Provider passed to 0x.js.
      */
     public async validateFillOrKillOrderThrowIfInvalidAsync(
         signedOrder: SignedOrder,
@@ -803,13 +825,14 @@ export class ExchangeWrapper extends ContractWrapper {
         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);
         await this._orderValidationUtils.validateFillOrKillOrderThrowIfInvalidAsync(
             exchangeTradeEmulator,
             signedOrder,
             fillTakerTokenAmount,
-            takerAddress,
+            normalizedTakerAddress,
             zrxTokenAddress,
         );
     }
@@ -839,20 +862,42 @@ export class ExchangeWrapper extends ContractWrapper {
         return isRoundingError;
     }
     /**
-     * Checks if logs contain LogError, which is emmited by Exchange contract on transaction failure.
+     * Checks if logs contain LogError, which is emitted by Exchange contract on transaction failure.
      * @param   logs   Transaction logs as returned by `zeroEx.awaitTransactionMinedAsync`
      */
-    public throwLogErrorsAsErrors(logs: Array<LogWithDecodedArgs<DecodedLogArgs> | Web3.LogEntry>): void {
+    public throwLogErrorsAsErrors(logs: Array<LogWithDecodedArgs<DecodedLogArgs> | LogEntry>): void {
         const errLog = _.find(logs, {
             event: ExchangeEvents.LogError,
         });
         if (!_.isUndefined(errLog)) {
             const logArgs = (errLog as LogWithDecodedArgs<LogErrorContractEventArgs>).args;
-            const errCode = logArgs.errorId.toNumber();
+            const errCode = logArgs.errorId;
             const errMessage = this._exchangeContractErrCodesToMsg[errCode];
             throw new Error(errMessage);
         }
     }
+    /**
+     * Gets the latest OrderState of a signedOrder
+     * @param   signedOrder   The signedOrder
+     * @param   stateLayer    Optional, desired blockchain state layer (defaults to latest).
+     * @return  OrderState of the signedOrder
+     */
+    public async getOrderStateAsync(
+        signedOrder: SignedOrder,
+        stateLayer: BlockParamLiteral = BlockParamLiteral.Latest,
+    ): Promise<OrderState> {
+        const simpleBalanceAndProxyAllowanceFetcher = new SimpleBalanceAndProxyAllowanceFetcher(
+            this._tokenWrapper,
+            stateLayer,
+        );
+        const simpleOrderFilledCancelledFetcher = new SimpleOrderFilledCancelledFetcher(this, stateLayer);
+        const orderStateUtils = new OrderStateUtils(
+            simpleBalanceAndProxyAllowanceFetcher,
+            simpleOrderFilledCancelledFetcher,
+        );
+        const orderState = orderStateUtils.getOrderStateAsync(signedOrder);
+        return orderState;
+    }
     /**
      * Returns the ZRX token address used by the exchange contract.
      * @return Address of ZRX token
@@ -862,7 +907,7 @@ export class ExchangeWrapper extends ContractWrapper {
         return contractAddress;
     }
     private _invalidateContractInstances(): void {
-        this._unsubscribeAll();
+        this.unsubscribeAll();
         delete this._exchangeContractIfExists;
     }
     private async _isValidSignatureUsingContractCallAsync(
@@ -873,11 +918,12 @@ export class ExchangeWrapper extends ContractWrapper {
         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(
-            signerAddressHex,
+            normalizedSignerAddress,
             dataHex,
             ecSignature.v,
             ecSignature.r,
@@ -895,11 +941,16 @@ export class ExchangeWrapper extends ContractWrapper {
         if (!_.isUndefined(this._exchangeContractIfExists)) {
             return this._exchangeContractIfExists;
         }
-        const web3ContractInstance = await this._instantiateContractIfExistsAsync(
+        const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
             artifacts.ExchangeArtifact,
             this._contractAddressIfExists,
         );
-        const contractInstance = new ExchangeContract(web3ContractInstance, this._web3Wrapper.getContractDefaults());
+        const contractInstance = new ExchangeContract(
+            abi,
+            address,
+            this._web3Wrapper.getProvider(),
+            this._web3Wrapper.getContractDefaults(),
+        );
         this._exchangeContractIfExists = contractInstance;
         return this._exchangeContractIfExists;
     }

packages/0x.js/src/contract_wrappers/generated/.gitignore

@@ -1,6 +0,0 @@
-dummy_token.ts
-ether_token.ts
-exchange.ts
-token_registry.ts
-token_transfer_proxy.ts
-token.ts

packages/0x.js/src/contract_wrappers/generated/base_contract.ts

@@ -1,33 +0,0 @@
-import {TxData, TxDataPayable} from '@0xproject/types';
-import * as _ from 'lodash';
-import * as Web3 from 'web3';
-
-export class BaseContract {
-    protected _web3ContractInstance: Web3.ContractInstance;
-    protected _defaults: Partial<TxData>;
-    protected async _applyDefaultsToTxDataAsync<T extends TxData|TxDataPayable>(
-        txData: T,
-        estimateGasAsync?: (txData: T) => Promise<number>,
-    ): Promise<TxData> {
-        // Gas amount sourced with the following priorities:
-        // 1. Optional param passed in to public method call
-        // 2. Global config passed in at library instantiation
-        // 3. Gas estimate calculation + safety margin
-        const removeUndefinedProperties = _.pickBy;
-        const txDataWithDefaults = {
-            ...removeUndefinedProperties(this._defaults),
-            ...removeUndefinedProperties(txData as any),
-            // HACK: TS can't prove that T is spreadable.
-            // Awaiting https://github.com/Microsoft/TypeScript/pull/13288 to be merged
-        };
-        if (_.isUndefined(txDataWithDefaults.gas) && !_.isUndefined(estimateGasAsync)) {
-            const estimatedGas = await estimateGasAsync(txData);
-            txDataWithDefaults.gas = estimatedGas;
-        }
-        return txDataWithDefaults;
-    }
-    constructor(web3ContractInstance: Web3.ContractInstance, defaults: Partial<TxData>) {
-        this._web3ContractInstance = web3ContractInstance;
-        this._defaults = defaults;
-    }
-}

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

@@ -23,7 +23,7 @@ export class TokenRegistryWrapper extends ContractWrapper {
             address: metadata[0],
             name: metadata[1],
             symbol: metadata[2],
-            decimals: metadata[3].toNumber(),
+            decimals: metadata[3],
         };
         return token;
     }
@@ -50,7 +50,8 @@ export class TokenRegistryWrapper extends ContractWrapper {
     public async getTokenAddressesAsync(): Promise<string[]> {
         const tokenRegistryContract = await this._getTokenRegistryContractAsync();
         const addresses = await tokenRegistryContract.getTokenAddresses.callAsync();
-        return addresses;
+        const lowerCaseAddresses = _.map(addresses, address => address.toLowerCase());
+        return lowerCaseAddresses;
     }
     /**
      * Retrieves a token by address currently listed in the Token Registry smart contract
@@ -58,9 +59,10 @@ export class TokenRegistryWrapper extends ContractWrapper {
      */
     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(address);
+        const metadata = await tokenRegistryContract.getTokenMetaData.callAsync(normalizedAddress);
         const token = TokenRegistryWrapper._createTokenFromMetadata(metadata);
         return token;
     }
@@ -115,12 +117,14 @@ export class TokenRegistryWrapper extends ContractWrapper {
         if (!_.isUndefined(this._tokenRegistryContractIfExists)) {
             return this._tokenRegistryContractIfExists;
         }
-        const web3ContractInstance = await this._instantiateContractIfExistsAsync(
+        const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
             artifacts.TokenRegistryArtifact,
             this._contractAddressIfExists,
         );
         const contractInstance = new TokenRegistryContract(
-            web3ContractInstance,
+            abi,
+            address,
+            this._web3Wrapper.getProvider(),
             this._web3Wrapper.getContractDefaults(),
         );
         this._tokenRegistryContractIfExists = contractInstance;

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

@@ -2,6 +2,7 @@ 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';
@@ -22,8 +23,12 @@ 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(exchangeContractAddress);
+        const isAuthorized = await tokenTransferProxyContractInstance.authorized.callAsync(
+            normalizedExchangeContractAddress,
+        );
         return isAuthorized;
     }
     /**
@@ -54,12 +59,14 @@ export class TokenTransferProxyWrapper extends ContractWrapper {
         if (!_.isUndefined(this._tokenTransferProxyContractIfExists)) {
             return this._tokenTransferProxyContractIfExists;
         }
-        const web3ContractInstance = await this._instantiateContractIfExistsAsync(
+        const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
             artifacts.TokenTransferProxyArtifact,
             this._contractAddressIfExists,
         );
         const contractInstance = new TokenTransferProxyContract(
-            web3ContractInstance,
+            abi,
+            address,
+            this._web3Wrapper.getProvider(),
             this._web3Wrapper.getContractDefaults(),
         );
         this._tokenTransferProxyContractIfExists = contractInstance;

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

@@ -22,13 +22,8 @@ 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,
-        abiDecoder: AbiDecoder,
-        tokenTransferProxyWrapper: TokenTransferProxyWrapper,
-    ) {
-        super(web3Wrapper, networkId, abiDecoder);
+    constructor(web3Wrapper: Web3Wrapper, networkId: number, tokenTransferProxyWrapper: TokenTransferProxyWrapper) {
+        super(web3Wrapper, networkId);
         this._tokenContractsByAddress = {};
         this._tokenTransferProxyWrapper = tokenTransferProxyWrapper;
     }
@@ -46,10 +41,13 @@ export class TokenWrapper extends ContractWrapper {
     ): Promise<BigNumber> {
         assert.isETHAddressHex('ownerAddress', ownerAddress);
         assert.isETHAddressHex('tokenAddress', tokenAddress);
+        const normalizedTokenAddress = tokenAddress.toLowerCase();
+        const normalizedOwnerAddress = ownerAddress.toLowerCase();
 
-        const tokenContract = await this._getTokenContractAsync(tokenAddress);
+        const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
         const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
-        let balance = await tokenContract.balanceOf.callAsync(ownerAddress, defaultBlock);
+        const txData = {};
+        let balance = await tokenContract.balanceOf.callAsync(normalizedOwnerAddress, txData, defaultBlock);
         // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
         balance = new BigNumber(balance);
         return balance;
@@ -72,14 +70,17 @@ export class TokenWrapper extends ContractWrapper {
         amountInBaseUnits: BigNumber,
         txOpts: TransactionOpts = {},
     ): 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(tokenAddress);
-        const txHash = await tokenContract.approve.sendTransactionAsync(spenderAddress, amountInBaseUnits, {
-            from: ownerAddress,
+        const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
+        const txHash = await tokenContract.approve.sendTransactionAsync(normalizedSpenderAddress, amountInBaseUnits, {
+            from: normalizedOwnerAddress,
             gas: txOpts.gasLimit,
             gasPrice: txOpts.gasPrice,
         });
@@ -103,10 +104,16 @@ export class TokenWrapper extends ContractWrapper {
         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();
         const txHash = await this.setAllowanceAsync(
-            tokenAddress,
-            ownerAddress,
-            spenderAddress,
+            normalizedTokenAddress,
+            normalizedOwnerAddress,
+            normalizedSpenderAddress,
             this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS,
             txOpts,
         );
@@ -128,10 +135,20 @@ export class TokenWrapper extends ContractWrapper {
     ): 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(tokenAddress);
+        const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
         const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
-        let allowanceInBaseUnits = await tokenContract.allowance.callAsync(ownerAddress, spenderAddress, defaultBlock);
+        const txData = {};
+        let allowanceInBaseUnits = await tokenContract.allowance.callAsync(
+            normalizedOwnerAddress,
+            normalizedSpenderAddress,
+            txData,
+            defaultBlock,
+        );
         // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
         allowanceInBaseUnits = new BigNumber(allowanceInBaseUnits);
         return allowanceInBaseUnits;
@@ -149,9 +166,16 @@ export class TokenWrapper extends ContractWrapper {
     ): 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(tokenAddress, ownerAddress, proxyAddress, methodOpts);
+        const allowanceInBaseUnits = await this.getAllowanceAsync(
+            normalizedTokenAddress,
+            normalizedOwnerAddress,
+            proxyAddress,
+            methodOpts,
+        );
         return allowanceInBaseUnits;
     }
     /**
@@ -172,12 +196,14 @@ export class TokenWrapper extends ContractWrapper {
     ): 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(
-            tokenAddress,
-            ownerAddress,
+            normalizedTokenAddress,
+            normalizedOwnerAddress,
             proxyAddress,
             amountInBaseUnits,
             txOpts,
@@ -200,9 +226,13 @@ export class TokenWrapper extends ContractWrapper {
         ownerAddress: string,
         txOpts: TransactionOpts = {},
     ): Promise<string> {
+        assert.isETHAddressHex('ownerAddress', ownerAddress);
+        assert.isETHAddressHex('tokenAddress', tokenAddress);
+        const normalizedTokenAddress = tokenAddress.toLowerCase();
+        const normalizedOwnerAddress = ownerAddress.toLowerCase();
         const txHash = await this.setProxyAllowanceAsync(
-            tokenAddress,
-            ownerAddress,
+            normalizedTokenAddress,
+            normalizedOwnerAddress,
             this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS,
             txOpts,
         );
@@ -225,19 +255,22 @@ export class TokenWrapper extends ContractWrapper {
         txOpts: TransactionOpts = {},
     ): Promise<string> {
         assert.isETHAddressHex('tokenAddress', tokenAddress);
-        await assert.isSenderAddressAsync('fromAddress', fromAddress, this._web3Wrapper);
         assert.isETHAddressHex('toAddress', toAddress);
+        await assert.isSenderAddressAsync('fromAddress', fromAddress, this._web3Wrapper);
+        const normalizedTokenAddress = tokenAddress.toLowerCase();
+        const normalizedFromAddress = fromAddress.toLowerCase();
+        const normalizedToAddress = toAddress.toLowerCase();
         assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
 
-        const tokenContract = await this._getTokenContractAsync(tokenAddress);
+        const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
 
-        const fromAddressBalance = await this.getBalanceAsync(tokenAddress, fromAddress);
+        const fromAddressBalance = await this.getBalanceAsync(normalizedTokenAddress, normalizedFromAddress);
         if (fromAddressBalance.lessThan(amountInBaseUnits)) {
             throw new Error(ZeroExError.InsufficientBalanceForTransfer);
         }
 
-        const txHash = await tokenContract.transfer.sendTransactionAsync(toAddress, amountInBaseUnits, {
-            from: fromAddress,
+        const txHash = await tokenContract.transfer.sendTransactionAsync(normalizedToAddress, amountInBaseUnits, {
+            from: normalizedFromAddress,
             gas: txOpts.gasLimit,
             gasPrice: txOpts.gasPrice,
         });
@@ -265,30 +298,38 @@ export class TokenWrapper extends ContractWrapper {
         amountInBaseUnits: BigNumber,
         txOpts: TransactionOpts = {},
     ): Promise<string> {
-        assert.isETHAddressHex('tokenAddress', tokenAddress);
-        assert.isETHAddressHex('fromAddress', fromAddress);
         assert.isETHAddressHex('toAddress', toAddress);
+        assert.isETHAddressHex('fromAddress', fromAddress);
+        assert.isETHAddressHex('tokenAddress', tokenAddress);
         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(tokenAddress);
+        const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
 
-        const fromAddressAllowance = await this.getAllowanceAsync(tokenAddress, fromAddress, senderAddress);
+        const fromAddressAllowance = await this.getAllowanceAsync(
+            normalizedTokenAddress,
+            normalizedFromAddress,
+            normalizedSenderAddress,
+        );
         if (fromAddressAllowance.lessThan(amountInBaseUnits)) {
             throw new Error(ZeroExError.InsufficientAllowanceForTransfer);
         }
 
-        const fromAddressBalance = await this.getBalanceAsync(tokenAddress, fromAddress);
+        const fromAddressBalance = await this.getBalanceAsync(normalizedTokenAddress, normalizedFromAddress);
         if (fromAddressBalance.lessThan(amountInBaseUnits)) {
             throw new Error(ZeroExError.InsufficientBalanceForTransfer);
         }
 
         const txHash = await tokenContract.transferFrom.sendTransactionAsync(
-            fromAddress,
-            toAddress,
+            normalizedFromAddress,
+            normalizedToAddress,
             amountInBaseUnits,
             {
-                from: senderAddress,
+                from: normalizedSenderAddress,
                 gas: txOpts.gasLimit,
                 gasPrice: txOpts.gasPrice,
             },
@@ -311,11 +352,12 @@ export class TokenWrapper extends ContractWrapper {
         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>(
-            tokenAddress,
+            normalizedTokenAddress,
             eventName,
             indexFilterValues,
             artifacts.TokenArtifact.abi,
@@ -333,12 +375,12 @@ export class TokenWrapper extends ContractWrapper {
     /**
      * Cancels all existing subscriptions
      */
-    public _unsubscribeAll(): void {
+    public unsubscribeAll(): void {
         super._unsubscribeAll();
     }
     /**
      * Gets historical logs without creating a subscription
-     * @param   tokenAddress        An address of the token that emmited the logs.
+     * @param   tokenAddress        An address of the token that emitted the logs.
      * @param   eventName           The 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
@@ -352,11 +394,12 @@ export class TokenWrapper extends ContractWrapper {
         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('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
         const logs = await this._getLogsAsync<ArgsType>(
-            tokenAddress,
+            normalizedTokenAddress,
             eventName,
             blockRange,
             indexFilterValues,
@@ -365,21 +408,27 @@ export class TokenWrapper extends ContractWrapper {
         return logs;
     }
     private _invalidateContractInstances(): void {
-        this._unsubscribeAll();
+        this.unsubscribeAll();
         this._tokenContractsByAddress = {};
     }
     private async _getTokenContractAsync(tokenAddress: string): Promise<TokenContract> {
-        let tokenContract = this._tokenContractsByAddress[tokenAddress];
+        const normalizedTokenAddress = tokenAddress.toLowerCase();
+        let tokenContract = this._tokenContractsByAddress[normalizedTokenAddress];
         if (!_.isUndefined(tokenContract)) {
             return tokenContract;
         }
-        const web3ContractInstance = await this._instantiateContractIfExistsAsync(
+        const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
             artifacts.TokenArtifact,
-            tokenAddress,
+            normalizedTokenAddress,
+        );
+        const contractInstance = new TokenContract(
+            abi,
+            address,
+            this._web3Wrapper.getProvider(),
+            this._web3Wrapper.getContractDefaults(),
         );
-        const contractInstance = new TokenContract(web3ContractInstance, this._web3Wrapper.getContractDefaults());
         tokenContract = contractInstance;
-        this._tokenContractsByAddress[tokenAddress] = tokenContract;
+        this._tokenContractsByAddress[normalizedTokenAddress] = tokenContract;
         return tokenContract;
     }
 }

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

@@ -0,0 +1,28 @@
+import { BlockParamLiteral } from '@0xproject/types';
+import { BigNumber } from '@0xproject/utils';
+
+import { BalanceAndProxyAllowanceFetcher } from '../abstract/balance_and_proxy_allowance_fetcher';
+import { TokenWrapper } from '../contract_wrappers/token_wrapper';
+
+export class SimpleBalanceAndProxyAllowanceFetcher implements BalanceAndProxyAllowanceFetcher {
+    private _tokenWrapper: TokenWrapper;
+    private _defaultBlock: BlockParamLiteral;
+    constructor(token: TokenWrapper, defaultBlock: BlockParamLiteral) {
+        this._tokenWrapper = token;
+        this._defaultBlock = defaultBlock;
+    }
+    public async getBalanceAsync(tokenAddress: string, userAddress: string): Promise<BigNumber> {
+        const methodOpts = {
+            defaultBlock: this._defaultBlock,
+        };
+        const balance = this._tokenWrapper.getBalanceAsync(tokenAddress, userAddress, methodOpts);
+        return balance;
+    }
+    public async getProxyAllowanceAsync(tokenAddress: string, userAddress: string): Promise<BigNumber> {
+        const methodOpts = {
+            defaultBlock: this._defaultBlock,
+        };
+        const proxyAllowance = this._tokenWrapper.getProxyAllowanceAsync(tokenAddress, userAddress, methodOpts);
+        return proxyAllowance;
+    }
+}

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

@@ -0,0 +1,28 @@
+import { BlockParamLiteral } from '@0xproject/types';
+import { BigNumber } from '@0xproject/utils';
+
+import { OrderFilledCancelledFetcher } from '../abstract/order_filled_cancelled_fetcher';
+import { ExchangeWrapper } from '../contract_wrappers/exchange_wrapper';
+
+export class SimpleOrderFilledCancelledFetcher implements OrderFilledCancelledFetcher {
+    private _exchangeWrapper: ExchangeWrapper;
+    private _defaultBlock: BlockParamLiteral;
+    constructor(exchange: ExchangeWrapper, defaultBlock: BlockParamLiteral) {
+        this._exchangeWrapper = exchange;
+        this._defaultBlock = defaultBlock;
+    }
+    public async getFilledTakerAmountAsync(orderHash: string): Promise<BigNumber> {
+        const methodOpts = {
+            defaultBlock: this._defaultBlock,
+        };
+        const filledTakerAmount = this._exchangeWrapper.getFilledTakerAmountAsync(orderHash, methodOpts);
+        return filledTakerAmount;
+    }
+    public async getCancelledTakerAmountAsync(orderHash: string): Promise<BigNumber> {
+        const methodOpts = {
+            defaultBlock: this._defaultBlock,
+        };
+        const cancelledTakerAmount = this._exchangeWrapper.getCancelledTakerAmountAsync(orderHash, methodOpts);
+        return cancelledTakerAmount;
+    }
+}

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

@@ -1,43 +1,6 @@
-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';
-
-// 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;
     /* tslint:disable */
     export default json;
     /* tslint:enable */
 }
-
-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;
-}

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

@@ -1,23 +0,0 @@
-import { BigNumber } from '@0xproject/utils';
-
-// 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,9 +1,6 @@
 export { ZeroEx } from './0x';
 
 export {
-    Order,
-    SignedOrder,
-    ECSignature,
     ZeroExError,
     EventCallback,
     ExchangeContractErrs,
@@ -14,12 +11,10 @@ export {
     OrderCancellationRequest,
     OrderFillRequest,
     ContractEventArgs,
-    Web3Provider,
     ZeroExConfig,
     MethodOpts,
     OrderTransactionOpts,
     TransactionOpts,
-    FilterObject,
     LogEvent,
     DecodedLogEvent,
     EventWatcherCallback,
@@ -31,9 +26,15 @@ export {
 
 export {
     BlockParamLiteral,
+    FilterObject,
     BlockParam,
     ContractEventArg,
     LogWithDecodedArgs,
+    Order,
+    Provider,
+    SignedOrder,
+    ECSignature,
+    TransactionReceipt,
     TransactionReceiptWithDecodedLogs,
 } from '@0xproject/types';
 
@@ -58,5 +59,3 @@ export {
     ExchangeContractEventArgs,
     ExchangeEvents,
 } from './contract_wrappers/generated/exchange';
-
-export { TransactionReceipt } from '@0xproject/types';

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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,9 +1,7 @@
+import { BlockParamLiteral, LogEntry } from '@0xproject/types';
 import { intervalUtils } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
-import * as Web3 from 'web3';
-
-import { BlockParamLiteral } from '@0xproject/types';
 
 import { EventWatcherCallback, ZeroExError } from '../types';
 import { assert } from '../utils/assert';
@@ -15,7 +13,7 @@ enum LogEventState {
     Added,
 }
 
-/*
+/**
  * The EventWatcher watches for blockchain events at the specified block confirmation
  * depth.
  */
@@ -23,9 +21,15 @@ export class EventWatcher {
     private _web3Wrapper: Web3Wrapper;
     private _pollingIntervalMs: number;
     private _intervalIdIfExists?: NodeJS.Timer;
-    private _lastEvents: Web3.LogEntry[] = [];
-    constructor(web3Wrapper: Web3Wrapper, pollingIntervalIfExistsMs: undefined | number) {
+    private _lastEvents: LogEntry[] = [];
+    private _stateLayer: BlockParamLiteral;
+    constructor(
+        web3Wrapper: Web3Wrapper,
+        pollingIntervalIfExistsMs: undefined | number,
+        stateLayer: BlockParamLiteral = BlockParamLiteral.Latest,
+    ) {
         this._web3Wrapper = web3Wrapper;
+        this._stateLayer = stateLayer;
         this._pollingIntervalMs = _.isUndefined(pollingIntervalIfExistsMs)
             ? DEFAULT_EVENT_POLLING_INTERVAL_MS
             : pollingIntervalIfExistsMs;
@@ -69,16 +73,16 @@ export class EventWatcher {
         await this._emitDifferencesAsync(newEvents, LogEventState.Added, callback);
         this._lastEvents = pendingEvents;
     }
-    private async _getEventsAsync(): Promise<Web3.LogEntry[]> {
+    private async _getEventsAsync(): Promise<LogEntry[]> {
         const eventFilter = {
-            fromBlock: BlockParamLiteral.Pending,
-            toBlock: BlockParamLiteral.Pending,
+            fromBlock: this._stateLayer,
+            toBlock: this._stateLayer,
         };
         const events = await this._web3Wrapper.getLogsAsync(eventFilter);
         return events;
     }
     private async _emitDifferencesAsync(
-        logs: Web3.LogEntry[],
+        logs: LogEntry[],
         logEventState: LogEventState,
         callback: EventWatcherCallback,
     ): Promise<void> {

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

@@ -48,6 +48,9 @@ export class ExpirationWatcher {
         this._orderHashByExpirationRBTree.insert(orderHash);
     }
     public removeOrder(orderHash: string): void {
+        if (_.isUndefined(this._expiration[orderHash])) {
+            return; // noop since order already removed
+        }
         this._orderHashByExpirationRBTree.remove(orderHash);
         delete this._expiration[orderHash];
     }

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

@@ -1,5 +1,5 @@
 import { schemas } from '@0xproject/json-schemas';
-import { BlockParamLiteral, LogWithDecodedArgs } from '@0xproject/types';
+import { BlockParamLiteral, LogWithDecodedArgs, SignedOrder } from '@0xproject/types';
 import { AbiDecoder, intervalUtils } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
@@ -31,7 +31,6 @@ import {
     OnOrderStateChangeCallback,
     OrderState,
     OrderStateWatcherConfig,
-    SignedOrder,
     ZeroExError,
 } from '../types';
 import { assert } from '../utils/assert';
@@ -60,7 +59,7 @@ 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 decison can be made on whether
+ * the subscriber of these changes so that a final decision can be made on whether
  * the order should be deemed invalid.
  */
 export class OrderStateWatcher {
@@ -70,7 +69,6 @@ export class OrderStateWatcher {
     private _callbackIfExists?: OnOrderStateChangeCallback;
     private _eventWatcher: EventWatcher;
     private _web3Wrapper: Web3Wrapper;
-    private _abiDecoder: AbiDecoder;
     private _expirationWatcher: ExpirationWatcher;
     private _orderStateUtils: OrderStateUtils;
     private _orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore;
@@ -79,20 +77,17 @@ export class OrderStateWatcher {
     private _cleanupJobIntervalIdIfExists?: NodeJS.Timer;
     constructor(
         web3Wrapper: Web3Wrapper,
-        abiDecoder: AbiDecoder,
         token: TokenWrapper,
         exchange: ExchangeWrapper,
         config?: OrderStateWatcherConfig,
     ) {
-        this._abiDecoder = abiDecoder;
         this._web3Wrapper = web3Wrapper;
         const pollingIntervalIfExistsMs = _.isUndefined(config) ? undefined : config.eventPollingIntervalMs;
-        this._eventWatcher = new EventWatcher(web3Wrapper, pollingIntervalIfExistsMs);
-        this._balanceAndProxyAllowanceLazyStore = new BalanceAndProxyAllowanceLazyStore(
-            token,
-            BlockParamLiteral.Pending,
-        );
-        this._orderFilledCancelledLazyStore = new OrderFilledCancelledLazyStore(exchange);
+        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._orderFilledCancelledLazyStore = new OrderFilledCancelledLazyStore(exchange, stateLayer);
         this._orderStateUtils = new OrderStateUtils(
             this._balanceAndProxyAllowanceLazyStore,
             this._orderFilledCancelledLazyStore,
@@ -136,7 +131,7 @@ export class OrderStateWatcher {
         }
         delete this._orderByOrderHash[orderHash];
         delete this._orderStateByOrderHashCache[orderHash];
-        const exchange = (this._orderFilledCancelledLazyStore as any)._exchange as ExchangeWrapper;
+        const exchange = (this._orderFilledCancelledLazyStore as any)._exchangeWrapper as ExchangeWrapper;
         const zrxTokenAddress = exchange.getZRXTokenAddress();
 
         this._removeFromDependentOrderHashes(signedOrder.maker, zrxTokenAddress, orderHash);
@@ -232,7 +227,7 @@ export class OrderStateWatcher {
             return;
         }
         const log = logIfExists as LogEvent; // At this moment we are sure that no error occured and log is defined.
-        const maybeDecodedLog = this._abiDecoder.tryToDecodeLogOrNoop<ContractEventArgs>(log);
+        const maybeDecodedLog = this._web3Wrapper.abiDecoder.tryToDecodeLogOrNoop<ContractEventArgs>(log);
         const isLogDecoded = !_.isUndefined(((maybeDecodedLog as any) as LogWithDecodedArgs<ContractEventArgs>).event);
         if (!isLogDecoded) {
             return; // noop
@@ -379,7 +374,7 @@ export class OrderStateWatcher {
         }
     }
     private _getZRXTokenAddress(): string {
-        const exchange = (this._orderFilledCancelledLazyStore as any)._exchange as ExchangeWrapper;
+        const exchange = (this._orderFilledCancelledLazyStore as any)._exchangeWrapper as ExchangeWrapper;
         const zrxTokenAddress = exchange.getZRXTokenAddress();
         return zrxTokenAddress;
     }

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

@@ -1,7 +1,6 @@
+import { SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 
-import { SignedOrder } from '../types';
-
 export class RemainingFillableCalculator {
     private _signedOrder: SignedOrder;
     private _isMakerTokenZRX: boolean;

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

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

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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -2,13 +2,14 @@ import { BlockParamLiteral } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 
+import { BalanceAndProxyAllowanceFetcher } from '../abstract/balance_and_proxy_allowance_fetcher';
 import { TokenWrapper } from '../contract_wrappers/token_wrapper';
 
 /**
  * Copy on read store for balances/proxyAllowances of tokens/accounts
  */
-export class BalanceAndProxyAllowanceLazyStore {
-    private _token: TokenWrapper;
+export class BalanceAndProxyAllowanceLazyStore implements BalanceAndProxyAllowanceFetcher {
+    private _tokenWrapper: TokenWrapper;
     private _defaultBlock: BlockParamLiteral;
     private _balance: {
         [tokenAddress: string]: {
@@ -21,7 +22,7 @@ export class BalanceAndProxyAllowanceLazyStore {
         };
     };
     constructor(token: TokenWrapper, defaultBlock: BlockParamLiteral) {
-        this._token = token;
+        this._tokenWrapper = token;
         this._defaultBlock = defaultBlock;
         this._balance = {};
         this._proxyAllowance = {};
@@ -31,7 +32,7 @@ export class BalanceAndProxyAllowanceLazyStore {
             const methodOpts = {
                 defaultBlock: this._defaultBlock,
             };
-            const balance = await this._token.getBalanceAsync(tokenAddress, userAddress, methodOpts);
+            const balance = await this._tokenWrapper.getBalanceAsync(tokenAddress, userAddress, methodOpts);
             this.setBalance(tokenAddress, userAddress, balance);
         }
         const cachedBalance = this._balance[tokenAddress][userAddress];
@@ -59,7 +60,11 @@ export class BalanceAndProxyAllowanceLazyStore {
             const methodOpts = {
                 defaultBlock: this._defaultBlock,
             };
-            const proxyAllowance = await this._token.getProxyAllowanceAsync(tokenAddress, userAddress, methodOpts);
+            const proxyAllowance = await this._tokenWrapper.getProxyAllowanceAsync(
+                tokenAddress,
+                userAddress,
+                methodOpts,
+            );
             this.setProxyAllowance(tokenAddress, userAddress, proxyAllowance);
         }
         const cachedProxyAllowance = this._proxyAllowance[tokenAddress][userAddress];

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

@@ -2,30 +2,33 @@ import { BlockParamLiteral } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 
+import { OrderFilledCancelledFetcher } from '../abstract/order_filled_cancelled_fetcher';
 import { ExchangeWrapper } from '../contract_wrappers/exchange_wrapper';
 
 /**
  * Copy on read store for filled/cancelled taker amounts
  */
-export class OrderFilledCancelledLazyStore {
-    private _exchange: ExchangeWrapper;
+export class OrderFilledCancelledLazyStore implements OrderFilledCancelledFetcher {
+    private _exchangeWrapper: ExchangeWrapper;
+    private _defaultBlock: BlockParamLiteral;
     private _filledTakerAmount: {
         [orderHash: string]: BigNumber;
     };
     private _cancelledTakerAmount: {
         [orderHash: string]: BigNumber;
     };
-    constructor(exchange: ExchangeWrapper) {
-        this._exchange = exchange;
+    constructor(exchange: ExchangeWrapper, defaultBlock: BlockParamLiteral) {
+        this._exchangeWrapper = exchange;
+        this._defaultBlock = defaultBlock;
         this._filledTakerAmount = {};
         this._cancelledTakerAmount = {};
     }
     public async getFilledTakerAmountAsync(orderHash: string): Promise<BigNumber> {
         if (_.isUndefined(this._filledTakerAmount[orderHash])) {
             const methodOpts = {
-                defaultBlock: BlockParamLiteral.Pending,
+                defaultBlock: this._defaultBlock,
             };
-            const filledTakerAmount = await this._exchange.getFilledTakerAmountAsync(orderHash, methodOpts);
+            const filledTakerAmount = await this._exchangeWrapper.getFilledTakerAmountAsync(orderHash, methodOpts);
             this.setFilledTakerAmount(orderHash, filledTakerAmount);
         }
         const cachedFilled = this._filledTakerAmount[orderHash];
@@ -40,9 +43,12 @@ export class OrderFilledCancelledLazyStore {
     public async getCancelledTakerAmountAsync(orderHash: string): Promise<BigNumber> {
         if (_.isUndefined(this._cancelledTakerAmount[orderHash])) {
             const methodOpts = {
-                defaultBlock: BlockParamLiteral.Pending,
+                defaultBlock: this._defaultBlock,
             };
-            const cancelledTakerAmount = await this._exchange.getCancelledTakerAmountAsync(orderHash, methodOpts);
+            const cancelledTakerAmount = await this._exchangeWrapper.getCancelledTakerAmountAsync(
+                orderHash,
+                methodOpts,
+            );
             this.setCancelledTakerAmount(orderHash, cancelledTakerAmount);
         }
         const cachedCancelled = this._cancelledTakerAmount[orderHash];

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

@@ -1,6 +1,16 @@
 import { BigNumber } from '@0xproject/utils';
 
-import { BlockParam, BlockParamLiteral, ContractEventArg, LogWithDecodedArgs } from '@0xproject/types';
+import {
+    BlockParam,
+    BlockParamLiteral,
+    ContractAbi,
+    ContractEventArg,
+    FilterObject,
+    LogEntryEvent,
+    LogWithDecodedArgs,
+    Order,
+    SignedOrder,
+} from '@0xproject/types';
 
 import * as Web3 from 'web3';
 
@@ -28,7 +38,6 @@ export enum ZeroExError {
     NoNetworkId = 'NO_NETWORK_ID',
     SubscriptionNotFound = 'SUBSCRIPTION_NOT_FOUND',
     SubscriptionAlreadyPresent = 'SUBSCRIPTION_ALREADY_PRESENT',
-    TransactionMiningTimeout = 'TRANSACTION_MINING_TIMEOUT',
 }
 
 export enum InternalZeroExError {
@@ -37,20 +46,11 @@ export enum InternalZeroExError {
     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 LogEvent = Web3.LogEntryEvent;
+export type LogEvent = LogEntryEvent;
 export interface DecodedLogEvent<ArgsType> {
     isRemoved: boolean;
     log: LogWithDecodedArgs<ArgsType>;
@@ -107,27 +107,8 @@ export interface ContractEvent {
 
 export type ContractEventArgs = ExchangeContractEventArgs | TokenContractEventArgs | EtherTokenContractEventArgs;
 
-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, BigNumber, string, string];
+export type TokenMetadata = [string, string, string, number, string, string];
 
 export interface Token {
     name: string;
@@ -174,29 +155,23 @@ 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
- */
-export type Web3Provider = Web3.Provider;
-
-/*
- * orderExpirationCheckingIntervalMs: How often to check for expired orders. Default: 50
- * eventPollingIntervalMs: How often to poll the Ethereum node for new events. Defaults: 200
+ * orderExpirationCheckingIntervalMs: How often to check for expired orders. Default=50.
+ * eventPollingIntervalMs: How often to poll the Ethereum node for new events. Default=200.
  * expirationMarginMs: Amount of time before order expiry that you'd like to be notified
- * of an orders expiration. Defaults: 0
- * cleanupJobIntervalMs: How often to run a cleanup job which revalidates all the orders. Defaults: 1h
+ * of an orders expiration. Default=0.
+ * cleanupJobIntervalMs: How often to run a cleanup job which revalidates all the orders. Default=1hr.
+ * stateLayer: Optional blockchain state layer OrderWatcher will monitor for new events. Default=latest.
  */
 export interface OrderStateWatcherConfig {
     orderExpirationCheckingIntervalMs?: number;
     eventPollingIntervalMs?: number;
     expirationMarginMs?: number;
     cleanupJobIntervalMs?: number;
+    stateLayer: BlockParamLiteral;
 }
 
-/*
- * networkId: The id of the underlying ethereum network your provider is connected to. (1-mainnet, 42-kovan, 50-testrpc)
+/**
+ * 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
@@ -218,7 +193,7 @@ export type ArtifactContractName = 'ZRX' | 'TokenTransferProxy' | 'TokenRegistry
 
 export interface Artifact {
     contract_name: ArtifactContractName;
-    abi: Web3.ContractAbi;
+    abi: ContractAbi;
     networks: {
         [networkId: number]: {
             address: string;
@@ -226,7 +201,7 @@ export interface Artifact {
     };
 }
 
-/*
+/**
  * expectedFillTakerTokenAmount: If specified, the validation method will ensure that the
  * supplied order maker has a sufficient allowance/balance to fill this amount of the order's
  * takerTokenAmount. If not specified, the validation method ensures that the maker has a sufficient
@@ -236,17 +211,17 @@ export interface ValidateOrderFillableOpts {
     expectedFillTakerTokenAmount?: BigNumber;
 }
 
-/*
+/**
  * defaultBlock: The block up to which to query the blockchain state. Setting this to a historical block number
  * let's the user query the blockchain's state at an arbitrary point in time. In order for this to work, the
  * backing  Ethereum node must keep the entire historical state of the chain (e.g setting `--pruning=archive`
  * flag when  running Parity).
  */
 export interface MethodOpts {
-    defaultBlock?: Web3.BlockParam;
+    defaultBlock?: BlockParam;
 }
 
-/*
+/**
  * gasPrice: Gas price in Wei to use for a transaction
  * gasLimit: The amount of gas to send with a transaction
  */
@@ -255,16 +230,14 @@ export interface TransactionOpts {
     gasLimit?: number;
 }
 
-/*
+/**
  * shouldValidate: Flag indicating whether the library should make attempts to validate a transaction before
- * broadcasting it. For example, order has a valid signature, maker has sufficient funds, etc. Default: true
+ * broadcasting it. For example, order has a valid signature, maker has sufficient funds, etc. Default=true.
  */
 export interface OrderTransactionOpts extends TransactionOpts {
     shouldValidate?: boolean;
 }
 
-export type FilterObject = Web3.FilterObject;
-
 export enum TradeSide {
     Maker = 'maker',
     Taker = 'taker',

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

@@ -3,11 +3,11 @@ import { assert as sharedAssert } from '@0xproject/assert';
 // 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 { ECSignature } from '../types';
 import { signatureUtils } from '../utils/signature_utils';
 
 export const assert = {

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

@@ -1,8 +1,16 @@
+import {
+    ConstructorAbi,
+    ContractAbi,
+    EventAbi,
+    FallbackAbi,
+    FilterObject,
+    LogEntry,
+    MethodAbi,
+} from '@0xproject/types';
 import * as ethUtil from 'ethereumjs-util';
 import * as jsSHA3 from 'js-sha3';
 import * as _ from 'lodash';
 import * as uuid from 'uuid/v4';
-import * as Web3 from 'web3';
 
 import { BlockRange, ContractEvents, IndexedFilterValues } from '../types';
 
@@ -16,15 +24,15 @@ export const filterUtils = {
         address: string,
         eventName: ContractEvents,
         indexFilterValues: IndexedFilterValues,
-        abi: Web3.ContractAbi,
+        abi: ContractAbi,
         blockRange?: BlockRange,
-    ): Web3.FilterObject {
-        const eventAbi = _.find(abi, { name: eventName }) as Web3.EventAbi;
+    ): FilterObject {
+        const eventAbi = _.find(abi, { name: eventName }) as 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: Web3.FilterObject = {
+        let filter: FilterObject = {
             address,
             topics,
         };
@@ -36,12 +44,12 @@ export const filterUtils = {
         }
         return filter;
     },
-    getEventSignatureFromAbiByName(eventAbi: Web3.EventAbi, eventName: ContractEvents): string {
+    getEventSignatureFromAbiByName(eventAbi: EventAbi, eventName: ContractEvents): string {
         const types = _.map(eventAbi.inputs, 'type');
         const signature = `${eventAbi.name}(${types.join(',')})`;
         return signature;
     },
-    getTopicsForIndexedArgs(abi: Web3.EventAbi, indexFilterValues: IndexedFilterValues): Array<string | null> {
+    getTopicsForIndexedArgs(abi: EventAbi, indexFilterValues: IndexedFilterValues): Array<string | null> {
         const topics: Array<string | null> = [];
         for (const eventInput of abi.inputs) {
             if (!eventInput.indexed) {
@@ -60,7 +68,7 @@ export const filterUtils = {
         }
         return topics;
     },
-    matchesFilter(log: Web3.LogEntry, filter: Web3.FilterObject): boolean {
+    matchesFilter(log: LogEntry, filter: FilterObject): boolean {
         if (!_.isUndefined(filter.address) && log.address !== filter.address) {
             return false;
         }

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

@@ -1,25 +1,19 @@
+import { SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 
 import { ZeroEx } from '../0x';
+import { BalanceAndProxyAllowanceFetcher } from '../abstract/balance_and_proxy_allowance_fetcher';
+import { OrderFilledCancelledFetcher } from '../abstract/order_filled_cancelled_fetcher';
 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,
-    SignedOrder,
-} from '../types';
+import { ExchangeContractErrs, OrderRelevantState, OrderState, OrderStateInvalid, OrderStateValid } from '../types';
 
 const ACCEPTABLE_RELATIVE_ROUNDING_ERROR = 0.0001;
 
 export class OrderStateUtils {
-    private _balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore;
-    private _orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore;
+    private _balanceAndProxyAllowanceFetcher: BalanceAndProxyAllowanceFetcher;
+    private _orderFilledCancelledFetcher: OrderFilledCancelledFetcher;
     private static _validateIfOrderIsValid(signedOrder: SignedOrder, orderRelevantState: OrderRelevantState): void {
         const unavailableTakerTokenAmount = orderRelevantState.cancelledTakerTokenAmount.add(
             orderRelevantState.filledTakerTokenAmount,
@@ -55,11 +49,11 @@ export class OrderStateUtils {
         }
     }
     constructor(
-        balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore,
-        orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore,
+        balanceAndProxyAllowanceFetcher: BalanceAndProxyAllowanceFetcher,
+        orderFilledCancelledFetcher: OrderFilledCancelledFetcher,
     ) {
-        this._balanceAndProxyAllowanceLazyStore = balanceAndProxyAllowanceLazyStore;
-        this._orderFilledCancelledLazyStore = orderFilledCancelledLazyStore;
+        this._balanceAndProxyAllowanceFetcher = balanceAndProxyAllowanceFetcher;
+        this._orderFilledCancelledFetcher = orderFilledCancelledFetcher;
     }
     public async getOrderStateAsync(signedOrder: SignedOrder): Promise<OrderState> {
         const orderRelevantState = await this.getOrderRelevantStateAsync(signedOrder);
@@ -86,27 +80,27 @@ export class OrderStateUtils {
         // 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 exchange = (this._orderFilledCancelledFetcher as any)._exchangeWrapper as ExchangeWrapper;
         const zrxTokenAddress = exchange.getZRXTokenAddress();
         const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-        const makerBalance = await this._balanceAndProxyAllowanceLazyStore.getBalanceAsync(
+        const makerBalance = await this._balanceAndProxyAllowanceFetcher.getBalanceAsync(
             signedOrder.makerTokenAddress,
             signedOrder.maker,
         );
-        const makerProxyAllowance = await this._balanceAndProxyAllowanceLazyStore.getProxyAllowanceAsync(
+        const makerProxyAllowance = await this._balanceAndProxyAllowanceFetcher.getProxyAllowanceAsync(
             signedOrder.makerTokenAddress,
             signedOrder.maker,
         );
-        const makerFeeBalance = await this._balanceAndProxyAllowanceLazyStore.getBalanceAsync(
+        const makerFeeBalance = await this._balanceAndProxyAllowanceFetcher.getBalanceAsync(
             zrxTokenAddress,
             signedOrder.maker,
         );
-        const makerFeeProxyAllowance = await this._balanceAndProxyAllowanceLazyStore.getProxyAllowanceAsync(
+        const makerFeeProxyAllowance = await this._balanceAndProxyAllowanceFetcher.getProxyAllowanceAsync(
             zrxTokenAddress,
             signedOrder.maker,
         );
-        const filledTakerTokenAmount = await this._orderFilledCancelledLazyStore.getFilledTakerAmountAsync(orderHash);
-        const cancelledTakerTokenAmount = await this._orderFilledCancelledLazyStore.getCancelledTakerAmountAsync(
+        const filledTakerTokenAmount = await this._orderFilledCancelledFetcher.getFilledTakerAmountAsync(orderHash);
+        const cancelledTakerTokenAmount = await this._orderFilledCancelledFetcher.getCancelledTakerAmountAsync(
             orderHash,
         );
         const unavailableTakerTokenAmount = await exchange.getUnavailableTakerAmountAsync(orderHash);

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

@@ -1,9 +1,10 @@
+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, Order, SignedOrder, TradeSide, TransferType, ZeroExError } from '../types';
+import { ExchangeContractErrs, TradeSide, TransferType, ZeroExError } from '../types';
 import { constants } from '../utils/constants';
 import { utils } from '../utils/utils';
 

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

@@ -1,7 +1,6 @@
+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 {
         const dataBuff = ethUtil.toBuffer(data);

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

@@ -1,12 +1,10 @@
-import { SolidityTypes } from '@0xproject/types';
+import { Order, SignedOrder, SolidityTypes } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import BN = require('bn.js');
 import * as ethABI from 'ethereumjs-abi';
 import * as ethUtil from 'ethereumjs-util';
 import * as _ from 'lodash';
 
-import { Order, SignedOrder } from '../types';
-
 export const utils = {
     /**
      * Converts BigNumber instance to BN
@@ -17,10 +15,6 @@ 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);
-    },
     spawnSwitchErr(name: string, value: any): Error {
         return new Error(`Unexpected switch value: ${value} encountered for ${name}`);
     },

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

@@ -1,28 +1,39 @@
+import { Deployer } from '@0xproject/deployer';
 import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
+// HACK: This dependency is optional since it is only available when run from within
+// the monorepo. tslint doesn't handle optional dependencies
+// tslint:disable-next-line:no-implicit-dependencies
+import { runMigrationsAsync } from '@0xproject/migrations';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
 import * as _ from 'lodash';
 import 'mocha';
+import * as path from 'path';
 import * as Sinon from 'sinon';
 
 import { ApprovalContractEventArgs, LogWithDecodedArgs, Order, TokenEvents, ZeroEx } from '../src';
 
 import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
+import { deployer } from './utils/deployer';
 import { TokenUtils } from './utils/token_utils';
+import { provider, web3Wrapper } from './utils/web3_wrapper';
 
-const blockchainLifecycle = new BlockchainLifecycle();
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 chaiSetup.configure();
 const expect = chai.expect;
 
 const SHOULD_ADD_PERSONAL_MESSAGE_PREFIX = false;
 
 describe('ZeroEx library', () => {
-    const web3 = web3Factory.create();
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
-    const zeroEx = new ZeroEx(web3.currentProvider, config);
+    let zeroEx: ZeroEx;
+    before(async () => {
+        await runMigrationsAsync(deployer);
+        const config = {
+            networkId: constants.TESTRPC_NETWORK_ID,
+        };
+        zeroEx = new ZeroEx(provider, config);
+    });
     describe('#setProvider', () => {
         it('overrides provider in nested web3s and invalidates contractInstances', async () => {
             // Instantiate the contract instances with the current provider
@@ -31,21 +42,20 @@ describe('ZeroEx library', () => {
             expect((zeroEx.exchange as any)._exchangeContractIfExists).to.not.be.undefined();
             expect((zeroEx.tokenRegistry as any)._tokenRegistryContractIfExists).to.not.be.undefined();
 
-            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);
+            (provider as any).zeroExTestId = 1;
+            zeroEx.setProvider(provider, constants.TESTRPC_NETWORK_ID);
 
             // 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.getCurrentProvider();
+            const nestedWeb3WrapperProvider = (zeroEx as any)._web3Wrapper.getProvider();
             expect(nestedWeb3WrapperProvider.zeroExTestId).to.be.a('number');
-            const exchangeWeb3WrapperProvider = (zeroEx.exchange as any)._web3Wrapper.getCurrentProvider();
+            const exchangeWeb3WrapperProvider = (zeroEx.exchange as any)._web3Wrapper.getProvider();
             expect(exchangeWeb3WrapperProvider.zeroExTestId).to.be.a('number');
-            const tokenRegistryWeb3WrapperProvider = (zeroEx.tokenRegistry as any)._web3Wrapper.getCurrentProvider();
+            const tokenRegistryWeb3WrapperProvider = (zeroEx.tokenRegistry as any)._web3Wrapper.getProvider();
             expect(tokenRegistryWeb3WrapperProvider.zeroExTestId).to.be.a('number');
         });
     });
@@ -216,7 +226,7 @@ describe('ZeroEx library', () => {
                 s: '0x050aa3cc1f2c435e67e114cdce54b9527b4f50548342401bc5d2b77adbdacb02',
             };
             stubs = [
-                Sinon.stub((zeroEx as any)._web3Wrapper, 'signTransactionAsync').returns(Promise.resolve(signature)),
+                Sinon.stub((zeroEx as any)._web3Wrapper, 'signMessageAsync').returns(Promise.resolve(signature)),
                 Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
             ];
 
@@ -237,7 +247,7 @@ describe('ZeroEx library', () => {
                 s: '0x2dea66f25a608bbae457e020fb6decb763deb8b7192abab624997242da248960',
             };
             stubs = [
-                Sinon.stub((zeroEx as any)._web3Wrapper, 'signTransactionAsync').returns(Promise.resolve(signature)),
+                Sinon.stub((zeroEx as any)._web3Wrapper, 'signMessageAsync').returns(Promise.resolve(signature)),
                 Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
             ];
 
@@ -278,7 +288,7 @@ describe('ZeroEx library', () => {
                 exchangeContractAddress: ZeroEx.NULL_ADDRESS,
                 networkId: constants.TESTRPC_NETWORK_ID,
             };
-            const zeroExWithWrongExchangeAddress = new ZeroEx(web3.currentProvider, zeroExConfig);
+            const zeroExWithWrongExchangeAddress = new ZeroEx(provider, zeroExConfig);
             expect(zeroExWithWrongExchangeAddress.exchange.getContractAddress()).to.be.equal(ZeroEx.NULL_ADDRESS);
         });
         it('allows to specify token registry token contract address', async () => {
@@ -286,7 +296,7 @@ describe('ZeroEx library', () => {
                 tokenRegistryContractAddress: ZeroEx.NULL_ADDRESS,
                 networkId: constants.TESTRPC_NETWORK_ID,
             };
-            const zeroExWithWrongTokenRegistryAddress = new ZeroEx(web3.currentProvider, zeroExConfig);
+            const zeroExWithWrongTokenRegistryAddress = new ZeroEx(provider, zeroExConfig);
             expect(zeroExWithWrongTokenRegistryAddress.tokenRegistry.getContractAddress()).to.be.equal(
                 ZeroEx.NULL_ADDRESS,
             );

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

@@ -1,5 +1,5 @@
+import { web3Factory } from '@0xproject/dev-utils';
 import * as fs from 'fs';
-import HDWalletProvider = require('truffle-hdwallet-provider');
 
 import { ZeroEx } from '../src';
 
@@ -14,14 +14,11 @@ const TIMEOUT = 10000;
 describe('Artifacts', () => {
     describe('contracts are deployed on kovan', () => {
         const kovanRpcUrl = constants.KOVAN_RPC_URL;
-        const packageJSONContent = fs.readFileSync('package.json', 'utf-8');
-        const packageJSON = JSON.parse(packageJSONContent);
-        const mnemonic = packageJSON.config.mnemonic;
-        const web3Provider = new HDWalletProvider(mnemonic, kovanRpcUrl);
+        const provider = web3Factory.create({ rpcUrl: kovanRpcUrl }).currentProvider;
         const config = {
             networkId: constants.KOVAN_NETWORK_ID,
         };
-        const zeroEx = new ZeroEx(web3Provider, config);
+        const zeroEx = new ZeroEx(provider, config);
         it('token registry contract is deployed', async () => {
             await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
         }).timeout(TIMEOUT);
@@ -34,14 +31,11 @@ describe('Artifacts', () => {
     });
     describe('contracts are deployed on ropsten', () => {
         const ropstenRpcUrl = constants.ROPSTEN_RPC_URL;
-        const packageJSONContent = fs.readFileSync('package.json', 'utf-8');
-        const packageJSON = JSON.parse(packageJSONContent);
-        const mnemonic = packageJSON.config.mnemonic;
-        const web3Provider = new HDWalletProvider(mnemonic, ropstenRpcUrl);
+        const provider = web3Factory.create({ rpcUrl: ropstenRpcUrl }).currentProvider;
         const config = {
             networkId: constants.ROPSTEN_NETWORK_ID,
         };
-        const zeroEx = new ZeroEx(web3Provider, config);
+        const zeroEx = new ZeroEx(provider, config);
         it('token registry contract is deployed', async () => {
             await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
         }).timeout(TIMEOUT);

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

@@ -6,15 +6,15 @@ import { ZeroEx } from '../src';
 import { assert } from '../src/utils/assert';
 
 import { constants } from './utils/constants';
+import { provider } from './utils/web3_wrapper';
 
 const expect = chai.expect;
 
 describe('Assertion library', () => {
-    const web3 = web3Factory.create();
     const config = {
         networkId: constants.TESTRPC_NETWORK_ID,
     };
-    const zeroEx = new ZeroEx(web3.currentProvider, config);
+    const zeroEx = new ZeroEx(provider, config);
     describe('#isSenderAddressHexAsync', () => {
         it('throws when address is invalid', async () => {
             const address = '0xdeadbeef';

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

@@ -1,8 +1,8 @@
 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 Web3 from 'web3';
 
 import {
     ApprovalContractEventArgs,
@@ -23,10 +23,11 @@ import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
 import { reportNodeCallbackErrors } from './utils/report_callback_errors';
 import { TokenUtils } from './utils/token_utils';
+import { provider, web3Wrapper } from './utils/web3_wrapper';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle();
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 // 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
@@ -35,7 +36,6 @@ const blockchainLifecycle = new BlockchainLifecycle();
 const MAX_REASONABLE_GAS_COST_IN_WEI = 62517;
 
 describe('EtherTokenWrapper', () => {
-    let web3: Web3;
     let zeroEx: ZeroEx;
     let tokens: Token[];
     let userAddresses: string[];
@@ -54,13 +54,12 @@ describe('EtherTokenWrapper', () => {
     const depositAmount = new BigNumber(42);
     const withdrawalAmount = new BigNumber(42);
     before(async () => {
-        web3 = web3Factory.create();
-        zeroEx = new ZeroEx(web3.currentProvider, zeroExConfig);
+        zeroEx = new ZeroEx(provider, zeroExConfig);
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         addressWithETH = userAddresses[0];
         wethContractAddress = zeroEx.etherToken.getContractAddressIfExists() as string;
-        depositWeiAmount = (zeroEx as any)._web3Wrapper.toWei(new BigNumber(5));
+        depositWeiAmount = Web3Wrapper.toWei(new BigNumber(5));
         decimalPlaces = 7;
         addressWithoutFunds = userAddresses[1];
     });
@@ -75,11 +74,14 @@ describe('EtherTokenWrapper', () => {
             const contractAddressIfExists = zeroEx.etherToken.getContractAddressIfExists();
             expect(contractAddressIfExists).to.not.be.undefined();
         });
-        it('should return undefined if connected to an unknown network', () => {
+        it('should throw if connected to a private network and contract addresses are not specified', () => {
             const UNKNOWN_NETWORK_NETWORK_ID = 10;
-            const unknownNetworkZeroEx = new ZeroEx(web3.currentProvider, { networkId: UNKNOWN_NETWORK_NETWORK_ID });
-            const contractAddressIfExists = unknownNetworkZeroEx.etherToken.getContractAddressIfExists();
-            expect(contractAddressIfExists).to.be.undefined();
+            expect(
+                () =>
+                    new ZeroEx(provider, {
+                        networkId: UNKNOWN_NETWORK_NETWORK_ID,
+                    } as any),
+            ).to.throw();
         });
     });
     describe('#depositAsync', () => {
@@ -103,7 +105,7 @@ describe('EtherTokenWrapper', () => {
         it('should throw if user has insufficient ETH balance for deposit', async () => {
             const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
 
-            const extraETHBalance = (zeroEx as any)._web3Wrapper.toWei(5, 'ether');
+            const extraETHBalance = Web3Wrapper.toWei(new BigNumber(5));
             const overETHBalanceinWei = preETHBalance.add(extraETHBalance);
 
             return expect(
@@ -135,7 +137,7 @@ 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 withdrawl', async () => {
+        it('should throw if user has insufficient WETH balance for withdrawal', async () => {
             const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
             expect(preWETHBalance).to.be.bignumber.equal(0);
 
@@ -155,7 +157,7 @@ describe('EtherTokenWrapper', () => {
             etherTokenAddress = etherToken.address;
         });
         afterEach(() => {
-            zeroEx.etherToken._unsubscribeAll();
+            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,
@@ -258,8 +260,7 @@ describe('EtherTokenWrapper', () => {
                     callbackNeverToBeCalled,
                 );
                 const callbackToBeCalled = reportNodeCallbackErrors(done)();
-                const newProvider = web3Factory.getRpcProvider();
-                zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
+                zeroEx.setProvider(provider, constants.TESTRPC_NETWORK_ID);
                 await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
                 zeroEx.etherToken.subscribe(
                     etherTokenAddress,

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

@@ -1,10 +1,10 @@
 import { web3Factory } from '@0xproject/dev-utils';
+import { LogEntry } from '@0xproject/types';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 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';
@@ -12,16 +12,16 @@ import { DoneCallback } from '../src/types';
 
 import { chaiSetup } from './utils/chai_setup';
 import { reportNodeCallbackErrors } from './utils/report_callback_errors';
+import { provider } from './utils/web3_wrapper';
 
 chaiSetup.configure();
 const expect = chai.expect;
 
 describe('EventWatcher', () => {
-    let web3: Web3;
     let stubs: Sinon.SinonStub[] = [];
     let eventWatcher: EventWatcher;
     let web3Wrapper: Web3Wrapper;
-    const logA: Web3.LogEntry = {
+    const logA: LogEntry = {
         address: '0x71d271f8b14adef568f8f28f1587ce7271ac4ca5',
         blockHash: null,
         blockNumber: null,
@@ -31,7 +31,7 @@ describe('EventWatcher', () => {
         transactionHash: '0x004881d38cd4a8f72f1a0d68c8b9b8124504706041ff37019c1d1ed6bfda8e17',
         transactionIndex: 0,
     };
-    const logB: Web3.LogEntry = {
+    const logB: LogEntry = {
         address: '0x8d12a197cb00d4747a1fe03395095ce2a5cc6819',
         blockHash: null,
         blockNumber: null,
@@ -41,7 +41,7 @@ describe('EventWatcher', () => {
         transactionHash: '0x01ef3c048b18d9b09ea195b4ed94cf8dd5f3d857a1905ff886b152cfb1166f25',
         transactionIndex: 0,
     };
-    const logC: Web3.LogEntry = {
+    const logC: LogEntry = {
         address: '0x1d271f8b174adef58f1587ce68f8f27271ac4ca5',
         blockHash: null,
         blockNumber: null,
@@ -52,9 +52,8 @@ describe('EventWatcher', () => {
         transactionIndex: 0,
     };
     before(async () => {
-        web3 = web3Factory.create();
         const pollingIntervalMs = 10;
-        web3Wrapper = new Web3Wrapper(web3.currentProvider);
+        web3Wrapper = new Web3Wrapper(provider);
         eventWatcher = new EventWatcher(web3Wrapper, pollingIntervalMs);
     });
     afterEach(() => {
@@ -64,7 +63,7 @@ describe('EventWatcher', () => {
         eventWatcher.unsubscribe();
     });
     it('correctly emits initial log events', (done: DoneCallback) => {
-        const logs: Web3.LogEntry[] = [logA, logB];
+        const logs: LogEntry[] = [logA, logB];
         const expectedLogEvents = [
             {
                 removed: false,
@@ -89,8 +88,8 @@ describe('EventWatcher', () => {
         eventWatcher.subscribe(callback);
     });
     it('correctly computes the difference and emits only changes', (done: DoneCallback) => {
-        const initialLogs: Web3.LogEntry[] = [logA, logB];
-        const changedLogs: Web3.LogEntry[] = [logA, logC];
+        const initialLogs: LogEntry[] = [logA, logB];
+        const changedLogs: LogEntry[] = [logA, logC];
         const expectedLogEvents = [
             {
                 removed: false,

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

@@ -1,4 +1,4 @@
-import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
+import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
 import { BlockParamLiteral } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
@@ -9,17 +9,17 @@ import { ExchangeTransferSimulator } from '../src/utils/exchange_transfer_simula
 
 import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
+import { provider, web3Wrapper } from './utils/web3_wrapper';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle();
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 describe('ExchangeTransferSimulator', () => {
-    const web3 = web3Factory.create();
     const config = {
         networkId: constants.TESTRPC_NETWORK_ID,
     };
-    const zeroEx = new ZeroEx(web3.currentProvider, config);
+    const zeroEx = new ZeroEx(provider, config);
     const transferAmount = new BigNumber(5);
     let userAddresses: string[];
     let tokens: Token[];

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

@@ -4,7 +4,6 @@ import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
 import * as _ from 'lodash';
 import 'mocha';
-import * as Web3 from 'web3';
 
 import {
     BlockRange,
@@ -15,6 +14,7 @@ import {
     LogFillContractEventArgs,
     OrderCancellationRequest,
     OrderFillRequest,
+    OrderState,
     SignedOrder,
     Token,
     ZeroEx,
@@ -26,15 +26,15 @@ import { constants } from './utils/constants';
 import { FillScenarios } from './utils/fill_scenarios';
 import { reportNodeCallbackErrors } from './utils/report_callback_errors';
 import { TokenUtils } from './utils/token_utils';
+import { provider, web3Wrapper } from './utils/web3_wrapper';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle();
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 const NON_EXISTENT_ORDER_HASH = '0x79370342234e7acd6bbeac335bd3bb1d368383294b64b8160a00f4060e4d3777';
 
 describe('ExchangeWrapper', () => {
-    let web3: Web3;
     let zeroEx: ZeroEx;
     let tokenUtils: TokenUtils;
     let tokens: Token[];
@@ -46,8 +46,7 @@ describe('ExchangeWrapper', () => {
         networkId: constants.TESTRPC_NETWORK_ID,
     };
     before(async () => {
-        web3 = web3Factory.create();
-        zeroEx = new ZeroEx(web3.currentProvider, config);
+        zeroEx = new ZeroEx(provider, config);
         exchangeContractAddress = zeroEx.exchange.getContractAddress();
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
@@ -597,6 +596,19 @@ describe('ExchangeWrapper', () => {
                     const remainingFillAmount = fillableAmount.minus(1);
                     expect(anotherFilledAmount).to.be.bignumber.equal(remainingFillAmount);
                 });
+                it('should successfully fill up to specified amount and leave the rest of the orders untouched', async () => {
+                    const txHash = await zeroEx.exchange.fillOrdersUpToAsync(
+                        signedOrders,
+                        fillableAmount,
+                        shouldThrowOnInsufficientBalanceOrAllowance,
+                        takerAddress,
+                    );
+                    await zeroEx.awaitTransactionMinedAsync(txHash);
+                    const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
+                    const zeroAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
+                    expect(filledAmount).to.be.bignumber.equal(fillableAmount);
+                    expect(zeroAmount).to.be.bignumber.equal(0);
+                });
                 it('should successfully fill up to specified amount even if filling all orders would fail', async () => {
                     const missingBalance = new BigNumber(1); // User will still have enough balance to fill up to 9,
                     // but won't have 10 to fully fill all orders in a batch.
@@ -922,7 +934,7 @@ describe('ExchangeWrapper', () => {
             );
         });
         afterEach(async () => {
-            zeroEx.exchange._unsubscribeAll();
+            zeroEx.exchange.unsubscribeAll();
         });
         // Hack: Mocha does not allow a test to be both async and have a `done` callback
         // Since we need to await the receipt of the event in the `subscribe` callback,
@@ -965,8 +977,7 @@ describe('ExchangeWrapper', () => {
                 );
                 zeroEx.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callbackNeverToBeCalled);
 
-                const newProvider = web3Factory.getRpcProvider();
-                zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
+                zeroEx.setProvider(provider, constants.TESTRPC_NETWORK_ID);
 
                 const callback = reportNodeCallbackErrors(done)(
                     (logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
@@ -1144,4 +1155,41 @@ describe('ExchangeWrapper', () => {
             expect(args.maker).to.be.equal(differentMakerAddress);
         });
     });
+    describe('#getOrderStateAsync', () => {
+        let maker: string;
+        let taker: string;
+        let makerToken: Token;
+        let takerToken: Token;
+        let signedOrder: SignedOrder;
+        let orderState: OrderState;
+        const fillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(5), constants.ZRX_DECIMALS);
+        before(async () => {
+            [, maker, taker] = userAddresses;
+            tokens = await zeroEx.tokenRegistry.getTokensAsync();
+            [makerToken, takerToken] = tokenUtils.getDummyTokens();
+        });
+        it('should report orderStateValid when order is fillable', async () => {
+            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerToken.address,
+                takerToken.address,
+                maker,
+                taker,
+                fillableAmount,
+            );
+            orderState = await zeroEx.exchange.getOrderStateAsync(signedOrder);
+            expect(orderState.isValid).to.be.true();
+        });
+        it('should report orderStateInvalid when maker allowance set to 0', async () => {
+            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerToken.address,
+                takerToken.address,
+                maker,
+                taker,
+                fillableAmount,
+            );
+            await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, new BigNumber(0));
+            orderState = await zeroEx.exchange.getOrderStateAsync(signedOrder);
+            expect(orderState.isValid).to.be.false();
+        });
+    });
 }); // tslint:disable:max-file-line-count

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

@@ -1,28 +1,27 @@
-import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
+import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
 import { BigNumber } from '@0xproject/utils';
 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 { constants } from '../src/utils/constants';
 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 { provider, web3Wrapper } from './utils/web3_wrapper';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle();
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 describe('ExpirationWatcher', () => {
-    let web3: Web3;
     let zeroEx: ZeroEx;
     let tokenUtils: TokenUtils;
     let tokens: Token[];
@@ -41,11 +40,10 @@ describe('ExpirationWatcher', () => {
     let timer: Sinon.SinonFakeTimers;
     let expirationWatcher: ExpirationWatcher;
     before(async () => {
-        web3 = web3Factory.create();
         const config = {
             networkId: constants.TESTRPC_NETWORK_ID,
         };
-        zeroEx = new ZeroEx(web3.currentProvider, config);
+        zeroEx = new ZeroEx(provider, config);
         exchangeContractAddress = zeroEx.exchange.getContractAddress();
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         tokens = await zeroEx.tokenRegistry.getTokensAsync();

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

@@ -1,9 +1,8 @@
-import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
+import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
 import * as _ from 'lodash';
 import 'mocha';
-import * as Web3 from 'web3';
 
 import {
     ExchangeContractErrs,
@@ -15,6 +14,7 @@ import {
     ZeroEx,
     ZeroExError,
 } from '../src';
+import { OrderStateWatcher } from '../src/order_watcher/order_state_watcher';
 import { DoneCallback } from '../src/types';
 
 import { chaiSetup } from './utils/chai_setup';
@@ -22,15 +22,15 @@ import { constants } from './utils/constants';
 import { FillScenarios } from './utils/fill_scenarios';
 import { reportNodeCallbackErrors } from './utils/report_callback_errors';
 import { TokenUtils } from './utils/token_utils';
+import { provider, web3Wrapper } from './utils/web3_wrapper';
 
 const TIMEOUT_MS = 150;
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle();
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 describe('OrderStateWatcher', () => {
-    let web3: Web3;
     let zeroEx: ZeroEx;
     let tokens: Token[];
     let tokenUtils: TokenUtils;
@@ -43,14 +43,15 @@ describe('OrderStateWatcher', () => {
     let maker: string;
     let taker: string;
     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);
     before(async () => {
-        web3 = web3Factory.create();
-        zeroEx = new ZeroEx(web3.currentProvider, config);
+        zeroEx = new ZeroEx(provider, config);
+        orderStateWatcher = zeroEx.createOrderStateWatcher();
         exchangeContractAddress = zeroEx.exchange.getContractAddress();
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         [, maker, taker] = userAddresses;
@@ -77,17 +78,17 @@ describe('OrderStateWatcher', () => {
                 fillableAmount,
             );
             const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-            zeroEx.orderStateWatcher.addOrder(signedOrder);
-            expect((zeroEx.orderStateWatcher as any)._orderByOrderHash).to.include({
+            orderStateWatcher.addOrder(signedOrder);
+            expect((orderStateWatcher as any)._orderByOrderHash).to.include({
                 [orderHash]: signedOrder,
             });
-            let dependentOrderHashes = (zeroEx.orderStateWatcher as any)._dependentOrderHashes;
+            let dependentOrderHashes = (orderStateWatcher as any)._dependentOrderHashes;
             expect(dependentOrderHashes[signedOrder.maker][signedOrder.makerTokenAddress]).to.have.keys(orderHash);
-            zeroEx.orderStateWatcher.removeOrder(orderHash);
-            expect((zeroEx.orderStateWatcher as any)._orderByOrderHash).to.not.include({
+            orderStateWatcher.removeOrder(orderHash);
+            expect((orderStateWatcher as any)._orderByOrderHash).to.not.include({
                 [orderHash]: signedOrder,
             });
-            dependentOrderHashes = (zeroEx.orderStateWatcher as any)._dependentOrderHashes;
+            dependentOrderHashes = (orderStateWatcher as any)._dependentOrderHashes;
             expect(dependentOrderHashes[signedOrder.maker]).to.be.undefined();
         });
         it('should no-op when removing a non-existing order', async () => {
@@ -104,23 +105,23 @@ describe('OrderStateWatcher', () => {
                 .split('')
                 .reverse()
                 .join('')}`;
-            zeroEx.orderStateWatcher.removeOrder(nonExistentOrderHash);
+            orderStateWatcher.removeOrder(nonExistentOrderHash);
         });
     });
     describe('#subscribe', async () => {
         afterEach(async () => {
-            zeroEx.orderStateWatcher.unsubscribe();
+            orderStateWatcher.unsubscribe();
         });
         it('should fail when trying to subscribe twice', async () => {
-            zeroEx.orderStateWatcher.subscribe(_.noop);
-            expect(() => zeroEx.orderStateWatcher.subscribe(_.noop)).to.throw(ZeroExError.SubscriptionAlreadyPresent);
+            orderStateWatcher.subscribe(_.noop);
+            expect(() => orderStateWatcher.subscribe(_.noop)).to.throw(ZeroExError.SubscriptionAlreadyPresent);
         });
     });
     describe('tests with cleanup', async () => {
         afterEach(async () => {
-            zeroEx.orderStateWatcher.unsubscribe();
+            orderStateWatcher.unsubscribe();
             const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-            zeroEx.orderStateWatcher.removeOrder(orderHash);
+            orderStateWatcher.removeOrder(orderHash);
         });
         it('should emit orderStateInvalid when maker allowance set to 0 for watched order', (done: DoneCallback) => {
             (async () => {
@@ -132,14 +133,14 @@ describe('OrderStateWatcher', () => {
                     fillableAmount,
                 );
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                orderStateWatcher.addOrder(signedOrder);
                 const callback = reportNodeCallbackErrors(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);
                 });
-                zeroEx.orderStateWatcher.subscribe(callback);
+                orderStateWatcher.subscribe(callback);
                 await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, new BigNumber(0));
             })().catch(done);
         });
@@ -152,11 +153,11 @@ describe('OrderStateWatcher', () => {
                     taker,
                     fillableAmount,
                 );
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                orderStateWatcher.addOrder(signedOrder);
                 const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
                     throw new Error('OrderState callback fired for irrelevant order');
                 });
-                zeroEx.orderStateWatcher.subscribe(callback);
+                orderStateWatcher.subscribe(callback);
                 const notTheMaker = userAddresses[0];
                 const anyRecipient = taker;
                 const transferAmount = new BigNumber(2);
@@ -176,14 +177,14 @@ describe('OrderStateWatcher', () => {
                     fillableAmount,
                 );
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                orderStateWatcher.addOrder(signedOrder);
                 const callback = reportNodeCallbackErrors(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);
                 });
-                zeroEx.orderStateWatcher.subscribe(callback);
+                orderStateWatcher.subscribe(callback);
                 const anyRecipient = taker;
                 const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
                 await zeroEx.token.transferAsync(makerToken.address, maker, anyRecipient, makerBalance);
@@ -199,7 +200,7 @@ describe('OrderStateWatcher', () => {
                     fillableAmount,
                 );
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                orderStateWatcher.addOrder(signedOrder);
 
                 const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
                     expect(orderState.isValid).to.be.false();
@@ -207,7 +208,7 @@ describe('OrderStateWatcher', () => {
                     expect(invalidOrderState.orderHash).to.be.equal(orderHash);
                     expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
                 });
-                zeroEx.orderStateWatcher.subscribe(callback);
+                orderStateWatcher.subscribe(callback);
 
                 const shouldThrowOnInsufficientBalanceOrAllowance = true;
                 await zeroEx.exchange.fillOrderAsync(
@@ -231,7 +232,7 @@ describe('OrderStateWatcher', () => {
                 const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
                 const fillAmountInBaseUnits = new BigNumber(2);
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                orderStateWatcher.addOrder(signedOrder);
 
                 const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
                     expect(orderState.isValid).to.be.true();
@@ -248,7 +249,7 @@ describe('OrderStateWatcher', () => {
                     );
                     expect(orderRelevantState.makerBalance).to.be.bignumber.equal(remainingMakerBalance);
                 });
-                zeroEx.orderStateWatcher.subscribe(callback);
+                orderStateWatcher.subscribe(callback);
                 const shouldThrowOnInsufficientBalanceOrAllowance = true;
                 await zeroEx.exchange.fillOrderAsync(
                     signedOrder,
@@ -273,8 +274,8 @@ describe('OrderStateWatcher', () => {
                     taker,
                 );
                 const callback = reportNodeCallbackErrors(done)();
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
-                zeroEx.orderStateWatcher.subscribe(callback);
+                orderStateWatcher.addOrder(signedOrder);
+                orderStateWatcher.subscribe(callback);
                 await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, maker, new BigNumber(0));
             })().catch(done);
         });
@@ -293,7 +294,7 @@ describe('OrderStateWatcher', () => {
                     );
                     const fillAmountInBaseUnits = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
                     const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                    zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    orderStateWatcher.addOrder(signedOrder);
                     const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
                         expect(orderState.isValid).to.be.true();
                         const validOrderState = orderState as OrderStateValid;
@@ -306,7 +307,7 @@ describe('OrderStateWatcher', () => {
                             ZeroEx.toBaseUnitAmount(new BigNumber(8), decimals),
                         );
                     });
-                    zeroEx.orderStateWatcher.subscribe(callback);
+                    orderStateWatcher.subscribe(callback);
                     const shouldThrowOnInsufficientBalanceOrAllowance = true;
                     await zeroEx.exchange.fillOrderAsync(
                         signedOrder,
@@ -327,7 +328,7 @@ describe('OrderStateWatcher', () => {
                     );
 
                     const changedMakerApprovalAmount = ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals);
-                    zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    orderStateWatcher.addOrder(signedOrder);
 
                     const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
                         const validOrderState = orderState as OrderStateValid;
@@ -339,7 +340,7 @@ describe('OrderStateWatcher', () => {
                             changedMakerApprovalAmount,
                         );
                     });
-                    zeroEx.orderStateWatcher.subscribe(callback);
+                    orderStateWatcher.subscribe(callback);
                     await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, changedMakerApprovalAmount);
                 })().catch(done);
             });
@@ -357,7 +358,7 @@ describe('OrderStateWatcher', () => {
 
                     const remainingAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals);
                     const transferAmount = makerBalance.sub(remainingAmount);
-                    zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    orderStateWatcher.addOrder(signedOrder);
 
                     const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
                         expect(orderState.isValid).to.be.true();
@@ -370,7 +371,7 @@ describe('OrderStateWatcher', () => {
                             remainingAmount,
                         );
                     });
-                    zeroEx.orderStateWatcher.subscribe(callback);
+                    orderStateWatcher.subscribe(callback);
                     await zeroEx.token.transferAsync(makerToken.address, maker, ZeroEx.NULL_ADDRESS, transferAmount);
                 })().catch(done);
             });
@@ -392,7 +393,7 @@ describe('OrderStateWatcher', () => {
 
                     const remainingTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(4), decimals);
                     const transferTokenAmount = makerFee.sub(remainingTokenAmount);
-                    zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    orderStateWatcher.addOrder(signedOrder);
 
                     const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
                         expect(orderState.isValid).to.be.true();
@@ -402,7 +403,7 @@ describe('OrderStateWatcher', () => {
                             remainingTokenAmount,
                         );
                     });
-                    zeroEx.orderStateWatcher.subscribe(callback);
+                    orderStateWatcher.subscribe(callback);
                     await zeroEx.exchange.cancelOrderAsync(signedOrder, transferTokenAmount);
                 })().catch(done);
             });
@@ -426,7 +427,7 @@ describe('OrderStateWatcher', () => {
 
                     const remainingTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(4), decimals);
                     const transferTokenAmount = makerFee.sub(remainingTokenAmount);
-                    zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    orderStateWatcher.addOrder(signedOrder);
 
                     const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
                         const validOrderState = orderState as OrderStateValid;
@@ -435,7 +436,7 @@ describe('OrderStateWatcher', () => {
                             remainingFeeAmount,
                         );
                     });
-                    zeroEx.orderStateWatcher.subscribe(callback);
+                    orderStateWatcher.subscribe(callback);
                     await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, maker, remainingFeeAmount);
                     await zeroEx.token.transferAsync(
                         makerToken.address,
@@ -461,7 +462,7 @@ describe('OrderStateWatcher', () => {
                         feeRecipient,
                     );
 
-                    zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    orderStateWatcher.addOrder(signedOrder);
 
                     const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
                         const validOrderState = orderState as OrderStateValid;
@@ -470,7 +471,7 @@ describe('OrderStateWatcher', () => {
                             fillableAmount,
                         );
                     });
-                    zeroEx.orderStateWatcher.subscribe(callback);
+                    orderStateWatcher.subscribe(callback);
                     await zeroEx.token.setProxyAllowanceAsync(
                         makerToken.address,
                         maker,
@@ -489,7 +490,7 @@ describe('OrderStateWatcher', () => {
                     fillableAmount,
                 );
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                orderStateWatcher.addOrder(signedOrder);
 
                 const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
                     expect(orderState.isValid).to.be.false();
@@ -497,7 +498,7 @@ describe('OrderStateWatcher', () => {
                     expect(invalidOrderState.orderHash).to.be.equal(orderHash);
                     expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
                 });
-                zeroEx.orderStateWatcher.subscribe(callback);
+                orderStateWatcher.subscribe(callback);
 
                 await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
             })().catch(done);
@@ -513,7 +514,7 @@ describe('OrderStateWatcher', () => {
                     fillableAmount,
                 );
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                orderStateWatcher.addOrder(signedOrder);
 
                 const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
                     expect(orderState.isValid).to.be.false();
@@ -521,7 +522,7 @@ describe('OrderStateWatcher', () => {
                     expect(invalidOrderState.orderHash).to.be.equal(orderHash);
                     expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderFillRoundingError);
                 });
-                zeroEx.orderStateWatcher.subscribe(callback);
+                orderStateWatcher.subscribe(callback);
                 await zeroEx.exchange.cancelOrderAsync(
                     signedOrder,
                     fillableAmount.minus(remainingFillableAmountInBaseUnits),
@@ -540,7 +541,7 @@ describe('OrderStateWatcher', () => {
 
                 const cancelAmountInBaseUnits = new BigNumber(2);
                 const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                orderStateWatcher.addOrder(signedOrder);
 
                 const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
                     expect(orderState.isValid).to.be.true();
@@ -549,7 +550,7 @@ describe('OrderStateWatcher', () => {
                     const orderRelevantState = validOrderState.orderRelevantState;
                     expect(orderRelevantState.cancelledTakerTokenAmount).to.be.bignumber.equal(cancelAmountInBaseUnits);
                 });
-                zeroEx.orderStateWatcher.subscribe(callback);
+                orderStateWatcher.subscribe(callback);
                 await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmountInBaseUnits);
             })().catch(done);
         });

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

@@ -1,9 +1,8 @@
-import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
+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';
@@ -14,13 +13,13 @@ import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
 import { FillScenarios } from './utils/fill_scenarios';
 import { TokenUtils } from './utils/token_utils';
+import { provider, web3Wrapper } from './utils/web3_wrapper';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle();
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 describe('OrderValidation', () => {
-    let web3: Web3;
     let zeroEx: ZeroEx;
     let userAddresses: string[];
     let tokens: Token[];
@@ -40,8 +39,7 @@ describe('OrderValidation', () => {
         networkId: constants.TESTRPC_NETWORK_ID,
     };
     before(async () => {
-        web3 = web3Factory.create();
-        zeroEx = new ZeroEx(web3.currentProvider, config);
+        zeroEx = new ZeroEx(provider, config);
         exchangeContractAddress = zeroEx.exchange.getContractAddress();
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;

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

@@ -1,10 +1,10 @@
+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 { ECSignature, SignedOrder } from '../src/types';
 
 import { chaiSetup } from './utils/chai_setup';
 

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

@@ -1,9 +1,8 @@
-import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
+import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
 import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 import 'mocha';
 import * as Sinon from 'sinon';
-import * as Web3 from 'web3';
 
 import { ApprovalContractEventArgs, DecodedLogEvent, Token, TokenEvents, ZeroEx } from '../src';
 import { DoneCallback } from '../src/types';
@@ -11,12 +10,12 @@ import { DoneCallback } from '../src/types';
 import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
 import { assertNodeCallbackError } from './utils/report_callback_errors';
+import { provider, web3Wrapper } from './utils/web3_wrapper';
 
 chaiSetup.configure();
-const blockchainLifecycle = new BlockchainLifecycle();
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 describe('SubscriptionTest', () => {
-    let web3: Web3;
     let zeroEx: ZeroEx;
     let userAddresses: string[];
     let tokens: Token[];
@@ -26,8 +25,7 @@ describe('SubscriptionTest', () => {
         networkId: constants.TESTRPC_NETWORK_ID,
     };
     before(async () => {
-        web3 = web3Factory.create();
-        zeroEx = new ZeroEx(web3.currentProvider, config);
+        zeroEx = new ZeroEx(provider, config);
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
         coinbase = userAddresses[0];
@@ -49,7 +47,7 @@ describe('SubscriptionTest', () => {
             tokenAddress = token.address;
         });
         afterEach(() => {
-            zeroEx.token._unsubscribeAll();
+            zeroEx.token.unsubscribeAll();
             _.each(stubs, s => s.restore());
             stubs = [];
         });
@@ -76,7 +74,7 @@ describe('SubscriptionTest', () => {
                 const callback = (err: Error | null, logEvent?: DecodedLogEvent<ApprovalContractEventArgs>) => _.noop;
                 zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
                 stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync').throws(new Error('JSON RPC error'))];
-                zeroEx.token._unsubscribeAll();
+                zeroEx.token.unsubscribeAll();
                 done();
             })().catch(done);
         });

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

@@ -1,4 +1,4 @@
-import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
+import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
 import { schemas, SchemaValidator } from '@0xproject/json-schemas';
 import * as chai from 'chai';
 import * as _ from 'lodash';
@@ -8,10 +8,11 @@ import { Token, ZeroEx } from '../src';
 
 import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
+import { provider, web3Wrapper } from './utils/web3_wrapper';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle();
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 const TOKEN_REGISTRY_SIZE_AFTER_MIGRATION = 7;
 
@@ -30,8 +31,7 @@ describe('TokenRegistryWrapper', () => {
         networkId: constants.TESTRPC_NETWORK_ID,
     };
     before(async () => {
-        const web3 = web3Factory.create();
-        zeroEx = new ZeroEx(web3.currentProvider, config);
+        zeroEx = new ZeroEx(provider, config);
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
         _.map(tokens, token => {
             tokenAddressBySymbol[token.symbol] = token.address;

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

@@ -1,10 +1,10 @@
-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 { provider } from './utils/web3_wrapper';
 
 chaiSetup.configure();
 const expect = chai.expect;
@@ -15,8 +15,7 @@ describe('TokenTransferProxyWrapper', () => {
         networkId: constants.TESTRPC_NETWORK_ID,
     };
     before(async () => {
-        const web3 = web3Factory.create();
-        zeroEx = new ZeroEx(web3.currentProvider, config);
+        zeroEx = new ZeroEx(provider, config);
     });
     describe('#isAuthorizedAsync', () => {
         it('should return false if the address is not authorized', async () => {

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

@@ -1,9 +1,10 @@
-import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
+import { BlockchainLifecycle, devConstants } from '@0xproject/dev-utils';
+import { EmptyWalletSubprovider } from '@0xproject/subproviders';
+import { Provider } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as chai from 'chai';
 import 'mocha';
-import * as Web3 from 'web3';
+import Web3ProviderEngine = require('web3-provider-engine');
 
 import {
     ApprovalContractEventArgs,
@@ -22,27 +23,24 @@ import { chaiSetup } from './utils/chai_setup';
 import { constants } from './utils/constants';
 import { reportNodeCallbackErrors } from './utils/report_callback_errors';
 import { TokenUtils } from './utils/token_utils';
+import { provider, web3Wrapper } from './utils/web3_wrapper';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle();
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 describe('TokenWrapper', () => {
-    let web3: Web3;
     let zeroEx: ZeroEx;
     let userAddresses: string[];
     let tokens: Token[];
     let tokenUtils: TokenUtils;
     let coinbase: string;
     let addressWithoutFunds: string;
-    let web3Wrapper: Web3Wrapper;
     const config = {
         networkId: constants.TESTRPC_NETWORK_ID,
     };
     before(async () => {
-        web3 = web3Factory.create();
-        zeroEx = new ZeroEx(web3.currentProvider, config);
-        web3Wrapper = new Web3Wrapper(web3.currentProvider);
+        zeroEx = new ZeroEx(provider, config);
         userAddresses = await zeroEx.getAvailableAddressesAsync();
         tokens = await zeroEx.tokenRegistry.getTokensAsync();
         tokenUtils = new TokenUtils(tokens);
@@ -167,7 +165,7 @@ describe('TokenWrapper', () => {
         });
     });
     describe('#getBalanceAsync', () => {
-        describe('With web3 provider with accounts', () => {
+        describe('With provider with accounts', () => {
             it('should return the balance for an existing ERC20 token', async () => {
                 const token = tokens[0];
                 const ownerAddress = coinbase;
@@ -190,14 +188,14 @@ describe('TokenWrapper', () => {
                 return expect(balance).to.be.bignumber.equal(expectedBalance);
             });
         });
-        describe('With web3 provider without accounts', () => {
+        describe('With provider without accounts', () => {
             let zeroExWithoutAccounts: ZeroEx;
             before(async () => {
                 const hasAddresses = false;
-                const web3WithoutAccounts = web3Factory.create(hasAddresses);
-                zeroExWithoutAccounts = new ZeroEx(web3WithoutAccounts.currentProvider, config);
+                const emptyWalletProvider = addEmptyWalletSubprovider(provider);
+                zeroExWithoutAccounts = new ZeroEx(emptyWalletProvider, config);
             });
-            it('should return balance even when called with Web3 provider instance without addresses', async () => {
+            it('should return balance even when called with provider instance without addresses', async () => {
                 const token = tokens[0];
                 const ownerAddress = coinbase;
                 const balance = await zeroExWithoutAccounts.token.getBalanceAsync(token.address, ownerAddress);
@@ -280,7 +278,7 @@ describe('TokenWrapper', () => {
         });
     });
     describe('#getAllowanceAsync', () => {
-        describe('With web3 provider with accounts', () => {
+        describe('With provider with accounts', () => {
             it('should get the proxy allowance', async () => {
                 const token = tokens[0];
                 const ownerAddress = coinbase;
@@ -302,12 +300,12 @@ describe('TokenWrapper', () => {
                 return expect(allowance).to.be.bignumber.equal(expectedAllowance);
             });
         });
-        describe('With web3 provider without accounts', () => {
+        describe('With provider without accounts', () => {
             let zeroExWithoutAccounts: ZeroEx;
             before(async () => {
                 const hasAddresses = false;
-                const web3WithoutAccounts = web3Factory.create(hasAddresses);
-                zeroExWithoutAccounts = new ZeroEx(web3WithoutAccounts.currentProvider, config);
+                const emptyWalletProvider = addEmptyWalletSubprovider(provider);
+                zeroExWithoutAccounts = new ZeroEx(emptyWalletProvider, config);
             });
             it('should get the proxy allowance', async () => {
                 const token = tokens[0];
@@ -377,7 +375,7 @@ describe('TokenWrapper', () => {
             tokenAddress = token.address;
         });
         afterEach(() => {
-            zeroEx.token._unsubscribeAll();
+            zeroEx.token.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,
@@ -427,8 +425,7 @@ describe('TokenWrapper', () => {
                 );
                 zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackNeverToBeCalled);
                 const callbackToBeCalled = reportNodeCallbackErrors(done)();
-                const newProvider = web3Factory.getRpcProvider();
-                zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
+                zeroEx.setProvider(provider, constants.TESTRPC_NETWORK_ID);
                 zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackToBeCalled);
                 await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
             })().catch(done);
@@ -518,3 +515,14 @@ describe('TokenWrapper', () => {
     });
 });
 // tslint:disable:max-file-line-count
+
+function addEmptyWalletSubprovider(p: Provider): Provider {
+    const providerEngine = new Web3ProviderEngine();
+    providerEngine.addProvider(new EmptyWalletSubprovider());
+    const currentSubproviders = (p as any)._providers;
+    for (const subprovider of currentSubproviders) {
+        providerEngine.addProvider(subprovider);
+    }
+    providerEngine.start();
+    return providerEngine;
+}

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

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

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

@@ -35,12 +35,13 @@ export class FillScenarios {
         const web3Wrapper = (this._zeroEx as any)._web3Wrapper as Web3Wrapper;
         for (const token of this._tokens) {
             if (token.symbol !== 'ZRX' && token.symbol !== 'WETH') {
-                const contractInstance = web3Wrapper.getContractInstance(
+                const defaults = {};
+                const dummyToken = new DummyTokenContract(
                     artifacts.DummyTokenArtifact.abi,
                     token.address,
+                    web3Wrapper.getProvider(),
+                    web3Wrapper.getContractDefaults(),
                 );
-                const defaults = {};
-                const dummyToken = new DummyTokenContract(contractInstance, defaults);
                 const tokenSupply = ZeroEx.toBaseUnitAmount(INITIAL_COINBASE_TOKEN_SUPPLY_IN_UNITS, token.decimals);
                 const txHash = await dummyToken.setBalance.sendTransactionAsync(this._coinbase, tokenSupply, {
                     from: this._coinbase,

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

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

packages/0x.js/tsconfig.json

@@ -1,16 +1,7 @@
 {
     "extends": "../../tsconfig",
     "compilerOptions": {
-        "outDir": "lib",
-        "noImplicitThis": false
+        "outDir": "lib"
     },
-    "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"
-    ]
+    "include": ["./src/**/*", "./test/**/*"]
 }

packages/abi-gen/.npmignore

@@ -3,3 +3,4 @@ yarn-error.log
 /src/
 /scripts/
 tsconfig.json
+/lib/monorepo_scripts/

packages/abi-gen/CHANGELOG.json

@@ -0,0 +1,111 @@
+[
+    {
+        "timestamp": 1524044013,
+        "version": "0.2.11",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1523462196,
+        "version": "0.2.10",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1522673609,
+        "version": "0.2.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1522658513,
+        "version": "0.2.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "0.2.5",
+        "changes": [
+            {
+                "note": "Consolidate all `console.log` calls into `logUtils` in the `@0xproject/utils` package",
+                "pr": 452
+            }
+        ],
+        "timestamp": 1521298800
+    },
+    {
+        "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
+    },
+    {
+        "version": "0.2.1",
+        "changes": [
+            {
+                "note": "Fix publishing issue where .npmignore was not properly excluding undesired content",
+                "pr": 389
+            }
+        ],
+        "timestamp": 1518102000
+    },
+    {
+        "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
+    },
+    {
+        "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
+    }
+]

packages/abi-gen/CHANGELOG.md

@@ -1,4 +1,35 @@
-# CHANGELOG
+<!--
+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.11 - _April 18, 2018_
+
+    * Dependencies updated
+
+## v0.2.10 - _April 12, 2018_
+
+    * Dependencies updated
+
+## v0.2.9 - _April 2, 2018_
+
+    * Dependencies updated
+
+## v0.2.8 - _April 2, 2018_
+
+    * Dependencies updated
+
+## v0.2.5 - _March 18, 2018_
+
+    * Consolidate all `console.log` calls into `logUtils` in the `@0xproject/utils` package (#452)
+
+## v0.2.4 - _March 4, 2018_
+
+    * Add a `backend` parameter that allows you to specify the Ethereum library you use in your templates (`web3` or `ethers`). Ethers auto-converts small ints to numbers whereas Web3 doesn't. Defaults to `web3` (#413)
+    * Add support for [tuple types](https://solidity.readthedocs.io/en/develop/abi-spec.html#handling-tuple-types) (#413)
+    * Add `hasReturnValue` to context data (#413)
 
 ## v0.2.1 - _February 9, 2018_
 

packages/abi-gen/README.md

@@ -4,8 +4,8 @@ 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.js/tree/development/packages/0x.js/src/contract_wrappers/generated) check out 0x.js.
-[Here](https://github.com/0xProject/0x.js/tree/development/packages/0x.js/contract_templates) are the templates used to generate those files.
+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
 
@@ -16,35 +16,102 @@ For an example of the generated [wrapper files](https://github.com/0xProject/0x.
 ```
 abi-gen
 Options:
-  --help           Show help                                           [boolean]
-  --version        Show version number                                 [boolean]
-  --abiGlob        Glob pattern to search for ABI JSON files [string] [required]
-  --templates      Folder where to search for templates      [string] [required]
-  --output         Folder where to put the output files      [string] [required]
+  --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]
 ```
 
-## ABI files
-
 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.
 
-`--abiGlob 'src/artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry).json`
+`--abis 'src/artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry).json`
 
-We could've just used `--abiGlob 'src/artifacts/*.json` but we wanted to exclude some of the abi files.
+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.js/tree/development/packages/0x.js/contract_templates) and start adjusting them for your needs.
+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.js/tree/development/packages/abi-gen/src/types.ts) of what we pass to the render method.
+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.
+
+## Contributing
+
+We welcome improvements and fixes from the wider community! 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
+
+If this is your **first** time building this package, you must first build **all** packages within the monorepo. This is because packages that depend on other packages located inside this monorepo are symlinked when run from **within** the monorepo. This allows you to make changes across multiple packages without first publishing dependent packages to NPM. To build all packages, run the following from the monorepo root directory:
+
+```bash
+yarn lerna:rebuild
+```
+
+Or continuously rebuild on change:
+
+```bash
+yarn dev
+```
+
+You can also build this specific package by running the following from within its directory:
+
+```bash
+yarn build
+```
+
+or continuously rebuild on change:
+
+```bash
+yarn build:watch
+```
+
+### Clean
+
+```bash
+yarn clean
+```
+
+### Lint
+
+```bash
+yarn lint
+```

packages/abi-gen/package.json

@@ -1,49 +1,55 @@
 {
     "name": "@0xproject/abi-gen",
-    "version": "0.2.0",
+    "version": "0.2.11",
     "description": "Generate contract wrappers from ABI and handlebars templates",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
     "scripts": {
         "build:watch": "tsc -w",
         "lint": "tslint --project . 'src/**/*.ts'",
-        "clean": "shx rm -rf lib",
-        "build": "tsc"
+        "clean": "shx rm -rf lib scripts",
+        "build": "tsc && copyfiles -u 2 './lib/monorepo_scripts/**/*' ./scripts",
+        "manual:postpublish": "yarn build; node ./scripts/postpublish.js"
     },
     "bin": {
         "abi-gen": "lib/index.js"
     },
     "repository": {
         "type": "git",
-        "url": "https://github.com/0xProject/0x.js.git"
+        "url": "https://github.com/0xProject/0x-monorepo.git"
     },
     "license": "Apache-2.0",
     "bugs": {
-        "url": "https://github.com/0xProject/0x.js/issues"
+        "url": "https://github.com/0xProject/0x-monorepo/issues"
     },
-    "homepage": "https://github.com/0xProject/0x.js/packages/abi-gen/README.md",
+    "homepage": "https://github.com/0xProject/0x-monorepo/packages/abi-gen/README.md",
     "dependencies": {
-        "@0xproject/utils": "^0.3.1",
+        "@0xproject/types": "^0.6.1",
+        "@0xproject/typescript-typings": "^0.2.0",
+        "@0xproject/utils": "^0.5.2",
         "chalk": "^2.3.0",
         "glob": "^7.1.2",
         "handlebars": "^4.0.11",
         "lodash": "^4.17.4",
         "mkdirp": "^0.5.1",
         "to-snake-case": "^1.0.0",
-        "web3": "^0.20.0",
         "yargs": "^10.0.3"
     },
     "devDependencies": {
-        "@0xproject/tslint-config": "^0.4.7",
+        "@0xproject/monorepo-scripts": "^0.1.18",
+        "@0xproject/tslint-config": "^0.4.16",
         "@types/glob": "^5.0.33",
         "@types/handlebars": "^4.0.36",
         "@types/mkdirp": "^0.5.1",
         "@types/node": "^8.0.53",
         "@types/yargs": "^10.0.0",
+        "copyfiles": "^1.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
         "tslint": "5.8.0",
-        "typescript": "2.7.1",
-        "web3-typescript-typings": "^0.9.9"
+        "typescript": "2.7.1"
+    },
+    "publishConfig": {
+        "access": "public"
     }
 }

packages/abi-gen/scripts/postpublish.js

@@ -1,5 +0,0 @@
-const postpublish_utils = require('../../../scripts/postpublish_utils');
-const packageJSON = require('../package.json');
-
-const subPackageName = packageJSON.name;
-postpublish_utils.standardPostPublishAsync(subPackageName);

packages/abi-gen/src/globals.d.ts

@@ -1,4 +1,6 @@
-declare function toSnakeCase(str: string): string;
-declare module 'to-snake-case' {
-    export = toSnakeCase;
+declare module '*.json' {
+    const json: any;
+    /* tslint:disable */
+    export default json;
+    /* tslint:enable */
 }

packages/abi-gen/src/index.ts

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 
+import { AbiDefinition, ConstructorAbi, EventAbi, MethodAbi } from '@0xproject/types';
+import { abiUtils, logUtils } from '@0xproject/utils';
 import chalk from 'chalk';
 import * as fs from 'fs';
 import { sync as globSync } from 'glob';
@@ -9,15 +11,15 @@ import * as mkdirp from 'mkdirp';
 import * as yargs from 'yargs';
 
 import toSnakeCase = require('to-snake-case');
-import * as Web3 from 'web3';
 
-import { ContextData, ParamKind } from './types';
+import { ContextData, ContractsBackend, Method, ParamKind } from './types';
 import { utils } from './utils';
 
 const ABI_TYPE_CONSTRUCTOR = 'constructor';
 const ABI_TYPE_METHOD = 'function';
 const ABI_TYPE_EVENT = 'event';
 const DEFAULT_NETWORK_ID = 50;
+const DEFAULT_BACKEND = 'web3';
 
 const args = yargs
     .option('abis', {
@@ -43,6 +45,12 @@ const args = yargs
         demandOption: true,
         normalize: true,
     })
+    .option('backend', {
+        describe: `The backing Ethereum library your app uses. Either 'web3' or 'ethers'. Ethers auto-converts small ints to numbers whereas Web3 doesn't.`,
+        type: 'string',
+        choices: [ContractsBackend.Web3, ContractsBackend.Ethers],
+        default: DEFAULT_BACKEND,
+    })
     .option('network-id', {
         describe: 'ID of the network where contract ABIs are nested in artifacts',
         type: 'number',
@@ -55,7 +63,7 @@ const args = yargs
 
 function registerPartials(partialsGlob: string) {
     const partialTemplateFileNames = globSync(partialsGlob);
-    utils.log(`Found ${chalk.green(`${partialTemplateFileNames.length}`)} ${chalk.bold('partial')} templates`);
+    logUtils.log(`Found ${chalk.green(`${partialTemplateFileNames.length}`)} ${chalk.bold('partial')} templates`);
     for (const partialTemplateFileName of partialTemplateFileNames) {
         const namedContent = utils.getNamedContent(partialTemplateFileName);
         Handlebars.registerPartial(namedContent.name, namedContent.content);
@@ -70,12 +78,11 @@ function writeOutputFile(name: string, renderedTsCode: string): void {
     }
     const filePath = `${args.output}/${fileName}.ts`;
     fs.writeFileSync(filePath, renderedTsCode);
-    utils.log(`Created: ${chalk.bold(filePath)}`);
+    logUtils.log(`Created: ${chalk.bold(filePath)}`);
 }
 
-Handlebars.registerHelper('parameterType', utils.solTypeToTsType.bind(utils, ParamKind.Input));
-Handlebars.registerHelper('returnType', utils.solTypeToTsType.bind(utils, ParamKind.Output));
-
+Handlebars.registerHelper('parameterType', utils.solTypeToTsType.bind(utils, ParamKind.Input, args.backend));
+Handlebars.registerHelper('returnType', utils.solTypeToTsType.bind(utils, ParamKind.Output, args.backend));
 if (args.partials) {
     registerPartials(args.partials);
 }
@@ -84,17 +91,17 @@ const template = Handlebars.compile<ContextData>(mainTemplate.content);
 const abiFileNames = globSync(args.abis);
 
 if (_.isEmpty(abiFileNames)) {
-    utils.log(`${chalk.red(`No ABI files found.`)}`);
-    utils.log(`Please make sure you've passed the correct folder name and that the files have
+    logUtils.log(`${chalk.red(`No ABI files found.`)}`);
+    logUtils.log(`Please make sure you've passed the correct folder name and that the files have
                ${chalk.bold('*.json')} extensions`);
     process.exit(1);
 } else {
-    utils.log(`Found ${chalk.green(`${abiFileNames.length}`)} ${chalk.bold('ABI')} files`);
+    logUtils.log(`Found ${chalk.green(`${abiFileNames.length}`)} ${chalk.bold('ABI')} files`);
     mkdirp.sync(args.output);
 }
 for (const abiFileName of abiFileNames) {
     const namedContent = utils.getNamedContent(abiFileName);
-    utils.log(`Processing: ${chalk.bold(namedContent.name)}...`);
+    logUtils.log(`Processing: ${chalk.bold(namedContent.name)}...`);
     const parsedContent = JSON.parse(namedContent.content);
     let ABI;
     if (_.isArray(parsedContent)) {
@@ -105,35 +112,39 @@ for (const abiFileName of abiFileNames) {
         ABI = parsedContent.networks[args.networkId].abi; // 0x contracts package artifact
     }
     if (_.isUndefined(ABI)) {
-        utils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`);
-        utils.log(
+        logUtils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`);
+        logUtils.log(
             `Please make sure your ABI file is either an array with ABI entries or a truffle artifact or 0x deployer artifact`,
         );
         process.exit(1);
     }
 
-    let ctor = ABI.find((abi: Web3.AbiDefinition) => abi.type === ABI_TYPE_CONSTRUCTOR) as Web3.ConstructorAbi;
+    let ctor = ABI.find((abi: AbiDefinition) => abi.type === ABI_TYPE_CONSTRUCTOR) as ConstructorAbi;
     if (_.isUndefined(ctor)) {
         ctor = utils.getEmptyConstructor(); // The constructor exists, but it's implicit in JSON's ABI definition
     }
 
-    const methodAbis = ABI.filter((abi: Web3.AbiDefinition) => abi.type === ABI_TYPE_METHOD) as Web3.MethodAbi[];
-    const methodsData = _.map(methodAbis, methodAbi => {
-        _.map(methodAbi.inputs, (input, i: number) => {
+    const methodAbis = ABI.filter((abi: AbiDefinition) => abi.type === ABI_TYPE_METHOD) as MethodAbi[];
+    const sanitizedMethodAbis = abiUtils.renameOverloadedMethods(methodAbis) as MethodAbi[];
+    const methodsData = _.map(methodAbis, (methodAbi, methodAbiIndex: number) => {
+        _.forEach(methodAbi.inputs, (input, inputIndex: number) => {
             if (_.isEmpty(input.name)) {
                 // Auto-generated getters don't have parameter names
-                input.name = `index_${i}`;
+                input.name = `index_${inputIndex}`;
             }
         });
         // This will make templates simpler
         const methodData = {
             ...methodAbi,
             singleReturnValue: methodAbi.outputs.length === 1,
+            hasReturnValue: methodAbi.outputs.length !== 0,
+            tsName: sanitizedMethodAbis[methodAbiIndex].name,
+            functionSignature: abiUtils.getFunctionSignature(methodAbi),
         };
         return methodData;
     });
 
-    const eventAbis = ABI.filter((abi: Web3.AbiDefinition) => abi.type === ABI_TYPE_EVENT) as Web3.EventAbi[];
+    const eventAbis = ABI.filter((abi: AbiDefinition) => abi.type === ABI_TYPE_EVENT) as EventAbi[];
 
     const contextData = {
         contractName: namedContent.name,

packages/abi-gen/src/monorepo_scripts/postpublish.ts

@@ -0,0 +1,8 @@
+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/abi-gen/src/types.ts

@@ -1,23 +1,24 @@
-import * as Web3 from 'web3';
+import { EventAbi, MethodAbi } from '@0xproject/types';
 
 export enum ParamKind {
     Input = 'input',
     Output = 'output',
 }
 
-export enum AbiType {
-    Function = 'function',
-    Constructor = 'constructor',
-    Event = 'event',
-    Fallback = 'fallback',
+export enum ContractsBackend {
+    Web3 = 'web3',
+    Ethers = 'ethers',
 }
 
-export interface Method extends Web3.MethodAbi {
+export interface Method extends MethodAbi {
     singleReturnValue: boolean;
+    hasReturnValue: boolean;
+    tsName: string;
+    functionSignature: string;
 }
 
 export interface ContextData {
     contractName: string;
     methods: Method[];
-    events: Web3.EventAbi[];
+    events: EventAbi[];
 }

packages/abi-gen/src/utils.ts

@@ -1,19 +1,20 @@
+import { AbiType, ConstructorAbi, DataItem } from '@0xproject/types';
 import * as fs from 'fs';
 import * as _ from 'lodash';
 import * as path from 'path';
-import * as Web3 from 'web3';
 
-import { AbiType, ParamKind } from './types';
+import { ContractsBackend, ParamKind } from './types';
 
 export const utils = {
-    solTypeToTsType(paramKind: ParamKind, solType: string): string {
+    solTypeToTsType(paramKind: ParamKind, backend: ContractsBackend, solType: string, components?: DataItem[]): string {
         const trailingArrayRegex = /\[\d*\]$/;
         if (solType.match(trailingArrayRegex)) {
             const arrayItemSolType = solType.replace(trailingArrayRegex, '');
-            const arrayItemTsType = utils.solTypeToTsType(paramKind, arrayItemSolType);
-            const arrayTsType = utils.isUnionType(arrayItemTsType)
-                ? `Array<${arrayItemTsType}>`
-                : `${arrayItemTsType}[]`;
+            const arrayItemTsType = utils.solTypeToTsType(paramKind, backend, arrayItemSolType, components);
+            const arrayTsType =
+                utils.isUnionType(arrayItemTsType) || utils.isObjectType(arrayItemTsType)
+                    ? `Array<${arrayItemTsType}>`
+                    : `${arrayItemTsType}[]`;
             return arrayTsType;
         } else {
             const solTypeRegexToTsType = [
@@ -24,27 +25,48 @@ export const utils = {
                 { regex: '^bytes\\d*$', tsType: 'string' },
             ];
             if (paramKind === ParamKind.Input) {
-                // web3 allows to pass those an non-bignumbers and that's nice
-                // but it always returns stuff as BigNumbers
+                // web3 and ethers allow to pass those as numbers instead of bignumbers
                 solTypeRegexToTsType.unshift({
                     regex: '^u?int(8|16|32)?$',
                     tsType: 'number|BigNumber',
                 });
             }
+            if (backend === ContractsBackend.Ethers && paramKind === ParamKind.Output) {
+                // ethers-contracts automatically converts small BigNumbers to numbers
+                solTypeRegexToTsType.unshift({
+                    regex: '^u?int(8|16|32|48)?$',
+                    tsType: 'number',
+                });
+            }
             for (const regexAndTxType of solTypeRegexToTsType) {
                 const { regex, tsType } = regexAndTxType;
                 if (solType.match(regex)) {
                     return tsType;
                 }
             }
+            const TUPLE_TYPE_REGEX = '^tuple$';
+            if (solType.match(TUPLE_TYPE_REGEX)) {
+                const componentsType = _.map(components, component => {
+                    const componentValueType = utils.solTypeToTsType(
+                        paramKind,
+                        backend,
+                        component.type,
+                        component.components,
+                    );
+                    const componentType = `${component.name}: ${componentValueType}`;
+                    return componentType;
+                });
+                const tsType = `{${componentsType}}`;
+                return tsType;
+            }
             throw new Error(`Unknown Solidity type found: ${solType}`);
         }
     },
     isUnionType(tsType: string): boolean {
         return tsType === 'number|BigNumber';
     },
-    log(...args: any[]): void {
-        console.log(...args); // tslint:disable-line:no-console
+    isObjectType(tsType: string): boolean {
+        return /^{.*}$/.test(tsType);
     },
     getPartialNameFromFileName(filename: string): string {
         const name = path.parse(filename).name;
@@ -62,7 +84,7 @@ export const utils = {
             throw new Error(`Failed to read ${filename}: ${err}`);
         }
     },
-    getEmptyConstructor(): Web3.ConstructorAbi {
+    getEmptyConstructor(): ConstructorAbi {
         return {
             type: AbiType.Constructor,
             stateMutability: 'nonpayable',

packages/abi-gen/tsconfig.json

@@ -3,5 +3,5 @@
     "compilerOptions": {
         "outDir": "lib"
     },
-    "include": ["./src/**/*", "./test/**/*", "../../node_modules/web3-typescript-typings/index.d.ts"]
+    "include": ["./src/**/*", "./test/**/*"]
 }

packages/assert/.npmignore

@@ -4,3 +4,4 @@ yarn-error.log
 /scripts/
 test/
 tsconfig.json
+/lib/src/monorepo_scripts/

packages/assert/CHANGELOG.json

@@ -0,0 +1,85 @@
+[
+    {
+        "timestamp": 1524044013,
+        "version": "0.2.7",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1523462196,
+        "version": "0.2.6",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1522673609,
+        "version": "0.2.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1522658513,
+        "version": "0.2.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "0.2.0",
+        "changes": [
+            {
+                "note": "Rename `isHttpUrl` to `isWebUri`",
+                "pr": 412
+            }
+        ],
+        "timestamp": 1520434800
+    },
+    {
+        "version": "0.1.0",
+        "changes": [
+            {
+                "note": "Remove isETHAddressHex checksum address check and assume address will be lowercased ",
+                "pr": 373
+            },
+            {
+                "note": "Add an optional parameter `subSchemas` to `doesConformToSchema` method",
+                "pr": 385
+            }
+        ],
+        "timestamp": 1520089200
+    },
+    {
+        "version": "0.0.18",
+        "changes": [
+            {
+                "note": "Fix publishing issue where .npmignore was not properly excluding undesired content",
+                "pr": 389
+            }
+        ],
+        "timestamp": 1486566000
+    },
+    {
+        "version": "0.0.4",
+        "changes": [
+            {
+                "note": "Re-publish Assert previously published under NPM package @0xproject/0x-assert"
+            },
+            {
+                "note":
+                    "Added assertion isValidBaseUnitAmount which checks both that the value is a valid bigNumber and that it does not contain decimals."
+            }
+        ],
+        "timestamp": 1510585200
+    }
+]

packages/assert/CHANGELOG.md

@@ -1,4 +1,34 @@
-# CHANGELOG
+<!--
+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.7 - _April 18, 2018_
+
+    * Dependencies updated
+
+## v0.2.6 - _April 12, 2018_
+
+    * Dependencies updated
+
+## v0.2.5 - _April 2, 2018_
+
+    * Dependencies updated
+
+## v0.2.4 - _April 2, 2018_
+
+    * Dependencies updated
+
+## v0.2.0 - _March 8, 2018_
+
+    * Rename `isHttpUrl` to `isWebUri` (#412)
+
+## v0.1.0 - _March 4, 2018_
+
+    * Remove isETHAddressHex checksum address check and assume address will be lowercased  (#373)
+    * Add an optional parameter `subSchemas` to `doesConformToSchema` method (#385)
 
 ## v0.0.18 - _February 9, 2017_
 

packages/assert/README.md

@@ -16,13 +16,21 @@ import { assert } from '@0xproject/assert';
 assert.isValidBaseUnitAmount('baseUnitAmount', baseUnitAmount);
 ```
 
+If your project is in [TypeScript](https://www.typescriptlang.org/), add the following to your `tsconfig.json`:
+
+```json
+"compilerOptions": {
+    "typeRoots": ["node_modules/@0xproject/typescript-typings/types", "node_modules/@types"],
+}
+```
+
 ## Contributing
 
-We strongly encourage that the community help us make improvements and determine the future direction of the protocol. To report bugs within this package, please create an issue in this repository.
+We welcome improvements and fixes from the wider community! 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
+### Install dependencies
 
 If you don't have yarn workspaces enabled (Yarn < v1.0) - enable them:
 
@@ -38,10 +46,36 @@ yarn install
 
 ### Build
 
+If this is your **first** time building this package, you must first build **all** packages within the monorepo. This is because packages that depend on other packages located inside this monorepo are symlinked when run from **within** the monorepo. This allows you to make changes across multiple packages without first publishing dependent packages to NPM. To build all packages, run the following from the monorepo root directory:
+
+```bash
+yarn lerna:rebuild
+```
+
+Or continuously rebuild on change:
+
+```bash
+yarn dev
+```
+
+You can also build this specific package by running the following from within its directory:
+
 ```bash
 yarn build
 ```
 
+or continuously rebuild on change:
+
+```bash
+yarn build:watch
+```
+
+### Clean
+
+```bash
+yarn clean
+```
+
 ### Lint
 
 ```bash

packages/assert/package.json

@@ -1,46 +1,55 @@
 {
     "name": "@0xproject/assert",
-    "version": "0.0.17",
+    "version": "0.2.7",
     "description": "Provides a standard way of performing type and schema validation across 0x projects",
     "main": "lib/src/index.js",
     "types": "lib/src/index.d.ts",
     "scripts": {
         "build:watch": "tsc -w",
-        "build": "tsc",
-        "clean": "shx rm -rf _bundles lib test_temp",
+        "build": "tsc && copyfiles -u 3 './lib/src/monorepo_scripts/**/*' ./scripts",
+        "clean": "shx rm -rf lib test_temp scripts",
         "lint": "tslint --project . 'src/**/*.ts' 'test/**/*.ts'",
-        "run_mocha": "mocha lib/test/**/*_test.js",
+        "run_mocha": "mocha lib/test/**/*_test.js --exit",
         "prepublishOnly": "run-p build",
         "test": "run-s clean build run_mocha",
-        "test:circleci": "yarn test"
+        "test:coverage": "nyc npm run test --all && yarn coverage:report:lcov",
+        "coverage:report:lcov": "nyc report --reporter=text-lcov > coverage/lcov.info",
+        "test:circleci": "yarn test:coverage",
+        "manual:postpublish": "yarn build; node ./scripts/postpublish.js"
     },
     "license": "Apache-2.0",
     "repository": {
         "type": "git",
-        "url": "https://github.com/0xProject/0x.js.git"
+        "url": "https://github.com/0xProject/0x-monorepo.git"
     },
     "bugs": {
-        "url": "https://github.com/0xProject/0x.js/issues"
+        "url": "https://github.com/0xProject/0x-monorepo/issues"
     },
-    "homepage": "https://github.com/0xProject/0x.js/packages/assert/README.md",
+    "homepage": "https://github.com/0xProject/0x-monorepo/packages/assert/README.md",
     "devDependencies": {
-        "@0xproject/tslint-config": "^0.4.7",
-        "@types/lodash": "^4.14.86",
+        "@0xproject/monorepo-scripts": "^0.1.18",
+        "@0xproject/tslint-config": "^0.4.16",
+        "@types/lodash": "4.14.104",
         "@types/mocha": "^2.2.42",
         "@types/valid-url": "^1.0.2",
         "chai": "^4.0.1",
-        "chai-typescript-typings": "^0.0.2",
+        "copyfiles": "^1.2.0",
         "dirty-chai": "^2.0.1",
         "mocha": "^4.0.1",
         "npm-run-all": "^4.1.2",
+        "nyc": "^11.0.1",
         "shx": "^0.2.2",
         "tslint": "5.8.0",
         "typescript": "2.7.1"
     },
     "dependencies": {
-        "@0xproject/json-schemas": "^0.7.9",
-        "@0xproject/utils": "^0.3.1",
+        "@0xproject/json-schemas": "^0.7.21",
+        "@0xproject/typescript-typings": "^0.2.0",
+        "@0xproject/utils": "^0.5.2",
         "lodash": "^4.17.4",
         "valid-url": "^1.0.9"
+    },
+    "publishConfig": {
+        "access": "public"
     }
 }

packages/assert/scripts/postpublish.js

@@ -1,5 +0,0 @@
-const postpublish_utils = require('../../../scripts/postpublish_utils');
-const packageJSON = require('../package.json');
-
-const subPackageName = packageJSON.name;
-postpublish_utils.standardPostPublishAsync(subPackageName);

packages/assert/src/globals.d.ts

@@ -1 +1,6 @@
-declare module 'dirty-chai';
+declare module '*.json' {
+    const json: any;
+    /* tslint:disable */
+    export default json;
+    /* tslint:enable */
+}